emsApplication/applications/examples/quc_demo/gaugeweather.cpp

#pragma execution_character_set("utf-8")

#include "gaugeweather.h"
//#include "qsvgrenderer.h"
#include "qpainter.h"
#include <QPainterPath>
#include "qmath.h"
#include "qtimer.h"
#include "qfile.h"
#include "qdebug.h"

GaugeWeather::GaugeWeather(QWidget *parent) : QWidget(parent)
{
    outerMinValue = 0;
    outerMaxValue = 100;
    outerStartAngle = 0;
    outerEndAngle = 0;
    outerValue = 0;
    outerCurrValue = 0;
    outerRingBgColor = QColor(250, 250, 250);
    outerRingColor = QColor(34, 163, 169);

    innerValue = 0;
    innerMinValue = -50;
    innerMaxValue = 50;
    innerStartAngle = 0;
    innerEndAngle = 135;
    innerCurrValue = 0;
    innerRingBgColor = QColor(250, 250, 250);
    innerRingNegativeColor = QColor(214, 5, 5);
    innerRingPositiveColor = QColor(0, 254, 254);

    innerScaleMajor = 2;
    innerScaleMinor = 0;
    innerScaleColor = QColor(255, 255, 255);
    innerScaleNumColor = QColor(255, 255, 255);

    centerPixMapNegativeColor = QColor(214, 5, 5);
    centerPixMapPositiveColor = QColor(0, 254, 254);

    outerValueTextColor = QColor(34, 163, 169);
    innerNegativeValueTextColor = QColor(214, 5, 5);
    innerPositiveValueTextColor = QColor(0, 254, 254);

    precision = 0;
    outerReverse = false;
    innerReverse = false;
    clockWise = true;

    animation = false;
    animationStep = 2;
    weatherType = WeatherType_SUNNY;
    centerSvgPath = ":/svg/weather-sunny.svg";

    outerTimer = new QTimer(this);
    outerTimer->setInterval(10);
    connect(outerTimer, SIGNAL(timeout()), this, SLOT(updateOuterValue()));

    innerTimer = new QTimer(this);
    innerTimer->setInterval(10);
    connect(innerTimer, SIGNAL(timeout()), this, SLOT(updateInnerValue()));

    setFont(QFont("Arial", 9));
}

GaugeWeather::~GaugeWeather()
{
    if (outerTimer->isActive())
    {
        outerTimer->stop();
    }

    if(innerTimer->isActive())
    {
        innerTimer->stop();
    }
}

void GaugeWeather::paintEvent(QPaintEvent *)
{
    int width = this->width();
    int height = this->height();
    int side = qMin(width, height);

    //绘制准备工作,启用反锯齿,平移坐标轴中心,等比例缩放
    QPainter painter(this);
    painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing);
    painter.translate(width / 2, height / 2);
    painter.scale(side / 200.0, side / 200.0);

    //绘制外环背景
    drawOuterRingBg(&painter);
    //绘制外环进度
    drawOuterRing(&painter);
    //绘制内环背景
    drawInnerRingBg(&painter);
    //绘制内环进度
    drawInnerRing(&painter);
    //绘制内环刻度值
    drawInnerRingScaleNum(&painter);
    //绘制中心图片
    drawCenterPixMap(&painter);
    //绘制数值
    drawValue(&painter);
}

void GaugeWeather::drawOuterRingBg(QPainter *painter)
{
    int radius = 99;
    painter->save();
    painter->setBrush(Qt::NoBrush);

    //绘制圆弧方法绘制圆环
    int penWidth = 13;
    QRectF rect(-radius + penWidth / 2, -radius + penWidth / 2, radius * 2 - penWidth, radius * 2 - penWidth);
    //可以自行修改画笔的后三个参数,形成各种各样的效果,例如Qt::FlatCap改为Qt::RoundCap可以产生圆角效果
    QPen pen(outerRingBgColor, penWidth, Qt::SolidLine, Qt::FlatCap, Qt::MPenJoinStyle);

    //计算总范围角度
    double angleAll = 360.0 - outerStartAngle - outerEndAngle;

    //绘制总范围角度圆弧
    pen.setColor(outerRingBgColor);
    painter->setPen(pen);
    painter->drawArc(rect, (270 - outerStartAngle - angleAll) * 16, angleAll * 16);
    painter->restore();
}

void GaugeWeather::drawOuterRing(QPainter *painter)
{
    int radius = 99;
    painter->save();
    painter->setBrush(Qt::NoBrush);

    //绘制圆弧方法绘制圆环
    int penWidth = 13;
    QRectF rect(-radius + penWidth / 2, -radius + penWidth / 2, radius * 2 - penWidth, radius * 2 - penWidth);
    //可以自行修改画笔的后三个参数,形成各种各样的效果,例如Qt::FlatCap改为Qt::RoundCap可以产生圆角效果
    QPen pen(outerRingColor, penWidth, Qt::SolidLine, Qt::FlatCap, Qt::MPenJoinStyle);

    //计算总范围角度,当前值范围角度,剩余值范围角度
    double angleAll = 360.0 - outerStartAngle - outerEndAngle;
    double angleCurrent = angleAll * ((outerCurrValue - outerMinValue) / (outerMaxValue - outerMinValue));

    //绘制当前值饼圆
    painter->setPen(pen);
    painter->drawArc(rect, (270 - outerStartAngle - angleCurrent) * 16, angleCurrent * 16);
    painter->restore();
}

void GaugeWeather::drawInnerRingBg(QPainter *painter)
{
    int radius = 77;
    painter->save();
    painter->setBrush(Qt::NoBrush);

    double penWidth = 13;
    QPen pen(innerRingBgColor, penWidth, Qt::SolidLine, Qt::FlatCap, Qt::MPenJoinStyle);
    painter->setPen(pen);

    double angleAll = 360.0 - innerStartAngle - innerEndAngle;
    QRectF rect = QRectF(-radius, -radius, radius * 2, radius * 2);

    //零值以上背景
    painter->drawArc(rect, (270 - innerStartAngle -  angleAll) * 16, angleAll * 16);
    //零值以下背景
    //painter->drawArc(rect,(270 -innerStartAngle -  null2MinAngle) * 16 ,null2MinAngle * 16);

    painter->restore();
}

void GaugeWeather::drawInnerRing(QPainter *painter)
{
    int radius = 77;
    painter->save();
    painter->setBrush(Qt::NoBrush);

    int penWidth = 13.5;
    QPen pen(innerRingPositiveColor, penWidth, Qt::SolidLine, Qt::FlatCap, Qt::MPenJoinStyle);

    double angleAll = 360.0 - innerStartAngle - innerEndAngle;
    double null2MinAngle = angleAll * (( 0 - innerMinValue) / (innerMaxValue - innerMinValue));  //零点所占的角度
    double nullUpAllAngle = angleAll - null2MinAngle;   //正基本角度
    double currAngle;
    if(innerCurrValue >= 0)
    {
        //正角度
        pen.setColor(innerRingNegativeColor);
        currAngle = nullUpAllAngle * (innerCurrValue / innerMaxValue)  * -1;
    }
    else
    {
        //负角度
        pen.setColor(innerRingPositiveColor);
        currAngle = null2MinAngle * (innerCurrValue / innerMinValue);
    }

    painter->setPen(pen);

    QRectF rect = QRectF(-radius, -radius, radius * 2, radius * 2);
    painter->drawArc(rect, (270 - innerStartAngle -  null2MinAngle) * 16, currAngle * 16);

    painter->restore();

}

void GaugeWeather::drawInnerRingScale(QPainter *painter)
{
    int radius = 76;
    painter->save();
    painter->setPen(innerScaleColor);

    painter->rotate(innerStartAngle);
    int steps = (innerScaleMajor * innerScaleMinor);
    double angleStep = (360.0 - innerStartAngle - innerEndAngle) / steps;
    QPen pen = painter->pen();
    pen.setCapStyle(Qt::RoundCap);

    for (int i = 0; i <= steps; i++)
    {
        if (i % innerScaleMinor == 0)
        {
            pen.setWidthF(1.5);
            painter->setPen(pen);
            painter->drawLine(0, radius - 12, 0, radius);
        }
        else
        {
            pen.setWidthF(1.0);
            painter->setPen(pen);
            painter->drawLine(0, radius - 5, 0, radius);
        }

        painter->rotate(angleStep);
    }

    painter->restore();
}

void GaugeWeather::drawInnerRingScaleNum(QPainter *painter)
{
    int radius = 60;
    painter->save();
    painter->setPen(innerScaleNumColor);

    double startRad = (360 - innerStartAngle - 90) * (M_PI / 180);
    double deltaRad = (360 - innerStartAngle - innerEndAngle) * (M_PI / 180) / innerScaleMajor;

    for (int i = 0; i <= innerScaleMajor; i++)
    {
        double sina = sin(startRad - i * deltaRad);
        double cosa = cos(startRad - i * deltaRad);
        double value = 1.0 * i * ((innerMaxValue - innerMinValue) / innerScaleMajor) + innerMinValue;

        QString strValue = QString("%1").arg((double)value, 0, 'f', precision);
        double textWidth = fontMetrics().size(Qt::TextSingleLine,strValue).width();// .width(strValue);
        double textHeight = fontMetrics().height();
        int x = radius * cosa - textWidth / 2;
        int y = -radius * sina + textHeight / 4;
        painter->drawText(x, y, strValue);
    }

    painter->restore();
}

void GaugeWeather::drawCenterPixMap(QPainter *painter)
{
    painter->save();
    // int width_svg = 50;
    // int height_svg = 50;

    // QFile file(centerSvgPath);
    // file.open(QIODevice::ReadOnly);
    // QByteArray baData = file.readAll();
    // //QDomDocument doc;
    // //doc.setContent(baData);
    // file.close();

    // //正负角度切换不同颜色
    // if(innerCurrValue >= 0)
    // {
    //     setColor(doc.documentElement(), "path", "fill", rgb2HexStr(centerPixMapNegativeColor));
    // }
    // else
    // {
    //     setColor(doc.documentElement(), "path", "fill", rgb2HexStr(centerPixMapPositiveColor));
    // }

    // QSvgRenderer m_svgRender(doc.toByteArray());
    // m_svgRender.render(painter, QRectF(-width_svg, -height_svg / 2, width_svg, height_svg));
    painter->restore();
}

void GaugeWeather::drawValue(QPainter *painter)
{
    painter->save();

    QFont font;
    font.setPixelSize(12);
    painter->setFont(font);
    painter->setPen(outerValueTextColor);

    QFontMetrics fm = painter->fontMetrics();
    QString outerStrValue = QString(tr("湿度: %1%")).arg(QString::number(outerCurrValue, 'f', 0));
    QRectF titleRect(5, 0, fm.size(Qt::TextSingleLine,outerStrValue).width(),fm.height());//width(outerStrValue), fm.height());
    painter->drawText(titleRect, Qt::AlignHCenter | Qt::AlignTop, outerStrValue);
    if(innerCurrValue >= 0 )
    {
        painter->setPen(innerNegativeValueTextColor);
    }
    else
    {
        painter->setPen(innerPositiveValueTextColor);
    }

    QString innerDir = innerCurrValue >= 0 ? "+" : "-";
    QString innerStrValue = QString(tr("温度: %1%2 ℃")).arg(innerDir).arg(QString::number(abs(innerCurrValue), 'f', 0));
    QRectF innerTitleRect(5, 0, fm.size(Qt::TextSingleLine,innerStrValue).width(),-fm.height()); //fm.width(innerStrValue), -fm.height());
    painter->drawText(innerTitleRect, Qt::AlignHCenter | Qt::AlignVCenter, innerStrValue);

    painter->restore();
}

QString GaugeWeather::rgb2HexStr(const QColor &color)
{
    QString redStr = QString("%1").arg(color.red(), 2, 16, QChar('0'));
    QString greenStr = QString("%1").arg(color.green(), 2, 16, QChar('0'));
    QString blueStr = QString("%1").arg(color.blue(), 2, 16, QChar('0'));
    QString key = "#" + redStr + greenStr + blueStr;
    return key;
}

// void GaugeWeather::setColor(QDomElement elem, QString strtagname, QString strattr, QString strattrval)
// {
//     if (elem.tagName().compare(strtagname) == 0) {
//         elem.setAttribute(strattr, strattrval);
//     }

//     for (int i = 0; i < elem.childNodes().count(); i++) {
//         if (!elem.childNodes().at(i).isElement()) {
//             continue;
//         }

//         setColor(elem.childNodes().at(i).toElement(), strtagname, strattr, strattrval);
//     }
// }

double GaugeWeather::getOuterValue() const
{
    return this->outerValue;
}

double GaugeWeather::getOuterMinValue() const
{
    return this->outerMinValue;
}

double GaugeWeather::getOuterMaxValue() const
{
    return this->outerMaxValue;
}

int GaugeWeather::getOuterStartAngle() const
{
    return this->outerStartAngle;
}

int GaugeWeather::getOuterEndAngle() const
{
    return this->outerEndAngle;
}

QColor GaugeWeather::getOuterRingBgColor() const
{
    return this->outerRingBgColor;
}

QColor GaugeWeather::getOuterRingColor() const
{
    return this->outerRingColor;
}

QColor GaugeWeather::getOuterValueTextColor() const
{
    return this->outerValueTextColor;
}

double GaugeWeather::getInnerMinValue() const
{
    return this->innerMinValue;
}

double GaugeWeather::getInnerMaxValue() const
{
    return this->innerMaxValue;
}

double GaugeWeather::getInnerValue() const
{
    return this->innerValue;
}

int GaugeWeather::getInnerStartAngle() const
{
    return this->innerStartAngle;
}

int GaugeWeather::getInnerEndAngle() const
{
    return this->innerEndAngle;
}

QColor GaugeWeather::getInnerRingBgColor() const
{
    return this->innerRingBgColor;
}

QColor GaugeWeather::getInnerNegativeColor() const
{
    return this->innerRingNegativeColor;
}

QColor GaugeWeather::getInnerPositiveColor() const
{
    return this->innerRingPositiveColor;
}

int GaugeWeather::getInnerScaleMajor() const
{
    return this->innerScaleMajor;
}

int GaugeWeather::getInnerScaleMinor() const
{
    return this->innerScaleMinor;
}

QColor GaugeWeather::getInnerScaleColor() const
{
    return this->innerScaleColor;
}

QColor GaugeWeather::getInnerScaleNumColor() const
{
    return this->innerScaleNumColor;
}

QColor GaugeWeather::getInnerNegativeValueTextColor() const
{
    return this->innerNegativeValueTextColor;
}

QColor GaugeWeather::getInnerPositiveValueTextColor() const
{
    return this->innerPositiveValueTextColor;
}

QColor GaugeWeather::getCenterPixMapNegativeColor() const
{
    return this->centerPixMapNegativeColor;
}

QColor GaugeWeather::getCenterPixMapPositiveColor() const
{
    return this->centerPixMapPositiveColor;
}

bool GaugeWeather::getAnimation() const
{
    return this->animation;
}

double GaugeWeather::getAnimationStep() const
{
    return this->animationStep;
}

GaugeWeather::WeatherType GaugeWeather::getWeatherType()  const
{
    return this->weatherType;
}

QSize GaugeWeather::sizeHint() const
{
    return QSize(200, 200);
}

QSize GaugeWeather::minimumSizeHint() const
{
    return QSize(50, 50);
}

void GaugeWeather::setOuterRange(double minValue, double maxValue)
{
    //如果最小值大于或者等于最大值则不设置
    if (minValue >= maxValue)
    {
        return;
    }

    this->outerMinValue = minValue;
    this->outerMaxValue = maxValue;

    //如果目标值不在范围值内,则重新设置目标值
    if (outerValue < minValue || outerValue > maxValue)
    {
        setOuterValue(outerValue);
    }

    this->update();
}

void GaugeWeather::setOuterMinValue(double value)
{
    setOuterRange(value, outerMaxValue);
}

void GaugeWeather::setOuterMaxValue(double value)
{
    setOuterRange(outerMinValue, value);
}

void GaugeWeather::setOuterValue(double value)
{
    //值小于最小值或者值大于最大值或者值和当前值一致则无需处理
    if (value < outerMinValue || value > outerMaxValue || value == this->outerValue)
    {
        return;
    }

    if (value > this->outerValue)
    {
        outerReverse = false;
    }
    else if (value < this->outerValue)
    {
        outerReverse = true;
    }

    this->outerValue = value;
    emit valueChanged(value);

    if (!animation)
    {
        outerCurrValue = this->outerValue;
        this->update();
    }
    else
    {
        outerTimer->start();
    }
}

void GaugeWeather::setOuterStartAngle(int startAngle)
{
    if (this->outerStartAngle != startAngle)
    {
        this->outerStartAngle = startAngle;
        this->update();
    }
}

void GaugeWeather::setOuterEndAngle(int endAngle)
{
    if (this->outerEndAngle != endAngle)
    {
        this->outerEndAngle = endAngle;
        this->update();
    }
}

void GaugeWeather::setOuterRingBgColor(const QColor &color)
{
    if (this->outerRingBgColor != color)
    {
        this->outerRingBgColor = color;
        this->update();
    }
}

void GaugeWeather::setOuterRingColor(const QColor &color)
{
    if (this->outerRingColor != color)
    {
        this->outerRingColor = color;
        this->update();
    }
}

void GaugeWeather::setOuterValueTextColor(const QColor &color)
{
    if (this->outerValueTextColor != color)
    {
        this->outerValueTextColor = color;
        this->update();
    }
}

void GaugeWeather::setInnerRange(double minValue, double maxValue)
{
    //如果最小值大于或者等于最大值则不设置
    if (minValue >= maxValue)
    {
        return;
    }

    this->innerMinValue = minValue;
    this->innerMaxValue = maxValue;

    //如果目标值不在范围值内,则重新设置目标值
    if (innerValue < minValue || innerValue > maxValue)
    {
        setInnerValue(innerValue);
    }

    this->update();
}

void GaugeWeather::setInnerMinValue(double value)
{
    setInnerRange(value, innerMaxValue);
}

void GaugeWeather::setInnerMaxValue(double value)
{
    setInnerRange(innerMinValue, value);
}

void GaugeWeather::setInnerValue(double value)
{
    //值小于最小值或者值大于最大值或者值和当前值一致则无需处理
    if (value < innerMinValue || value > innerMaxValue || value == this->innerValue)
    {
        return;
    }

    if(this->innerValue >= 0)
    {
        clockWise = true;
        if(value < this->innerValue)
        {
            //如果要设置的值小于已有的值，需要回滚
            innerReverse = true;
        }
        else
        {
            innerReverse = false;
        }
    }
    else
    {
        clockWise = false;
        if(value > this->innerValue)
        {
            //如果要设置的值大于已有的值，需要回滚
            innerReverse = true;
        }
        else
        {
            innerReverse = false;
        }
    }

    this->innerValue = value;
    emit valueChanged(value);

    if (!animation)
    {
        innerCurrValue = this->innerValue;
        this->update();
    }
    else
    {
        innerTimer->start();
    }
}

void GaugeWeather::setInnerStartAngle(int startAngle)
{
    if (this->innerStartAngle != startAngle)
    {
        this->innerStartAngle = startAngle;
        this->update();
    }
}

void GaugeWeather::setInnerEndAngle(int endAngle)
{
    if (this->innerEndAngle != endAngle)
    {
        this->innerEndAngle = endAngle;
        this->update();
    }
}

void GaugeWeather::setInnerRingBgColor(const QColor &color)
{
    if (this->innerRingBgColor != color)
    {
        this->innerRingBgColor = color;
        this->update();
    }
}

void GaugeWeather::setInnerNegativeColor(const QColor &color)
{
    if (this->innerRingNegativeColor != color)
    {
        this->innerRingNegativeColor = color;
        this->update();
    }
}

void GaugeWeather::setInnerPositiveColor(const QColor &color)
{
    if (this->innerRingPositiveColor != color)
    {
        this->innerRingPositiveColor = color;
        this->update();
    }
}

void GaugeWeather::setInnerScaleMajor(int value)
{
    if (this->innerScaleMajor != value)
    {
        this->innerScaleMajor = value;
        this->update();
    }
}

void GaugeWeather::setInnerScaleMinor(int value)
{
    if (this->innerScaleMinor != value)
    {
        this->innerScaleMinor = value;
        this->update();
    }
}

void GaugeWeather::setInnerScaleColor(const QColor &color)
{
    if (this->innerScaleColor != color)
    {
        this->innerScaleColor = color;
        this->update();
    }
}

void GaugeWeather::setInnerScaleNumColor(const QColor &color)
{
    if (this->innerScaleNumColor != color)
    {
        this->innerScaleNumColor = color;
        this->update();
    }
}

void GaugeWeather::setInnerNegativeValueTextColor(const QColor &color)
{
    if (this->innerNegativeValueTextColor != color)
    {
        this->innerNegativeValueTextColor = color;
        this->update();
    }
}

void GaugeWeather::setInnerPositiveValueTextColor(const QColor &color)
{
    if (this->innerPositiveValueTextColor != color)
    {
        this->innerPositiveValueTextColor = color;
        this->update();
    }
}

void GaugeWeather::setCenterPixMapNegativeColor(const QColor &color)
{
    if (this->centerPixMapNegativeColor != color)
    {
        this->centerPixMapNegativeColor = color;
        this->update();
    }
}

void GaugeWeather::setCenterPixMapPositiveColor(const QColor &color)
{
    if (this->centerPixMapPositiveColor != color)
    {
        this->centerPixMapPositiveColor = color;
        this->update();
    }
}

void GaugeWeather::setAnimation(bool animation)
{
    if (this->animation != animation)
    {
        this->animation = animation;
        this->update();
    }
}

void GaugeWeather::setAnimationStep(double animationStep)
{
    if (this->animationStep != animationStep)
    {
        this->animationStep = animationStep;
        this->update();
    }
}

void GaugeWeather::setWeatherType(GaugeWeather::WeatherType &type)
{
    if(this->weatherType != type)
    {
        this->weatherType = type;
        switch (type)
        {
        case WeatherType_SUNNY:
            centerSvgPath = ":/svg/weather-sunny.svg";
            break;
        case WeatherType_RAINY:
            centerSvgPath = ":/svg/weather-rainy.svg";
            break;
        case WeatherType_SNOWY:
            centerSvgPath = ":/svg/weather-snowy.svg";
            break;
        case WeatherType_CLOUDY:
            centerSvgPath = ":/svg/weather-cloudy.svg";
            break;
        case WeatherType_WINDY:
            centerSvgPath = ":/svg/weather-windy.svg";
            break;
        case WeatherType_SNOWY_RAINY:
            centerSvgPath = ":/svg/weather-snowy-rainy.svg";
            break;
        case WeatherType_HAIL:
            centerSvgPath = ":/svg/weather-hail.svg";
            break;
        case WeatherType_LIGHTNING:
            centerSvgPath = ":/svg/weather-lightning.svg";
            break;
        case WeatherType_FOG:
            centerSvgPath = ":/svg/weather-fog.svg";
            break;
        case WeatherType_PARTLYCLOUDY:
            centerSvgPath = ":/svg/weather-partlycloudy.svg";
            break;
        default:
            centerSvgPath = ":/svg/weather-sunny.svg";
            break;
        }

        this->update();
    }
}

void GaugeWeather::updateOuterValue()
{
    if (!outerReverse)
    {
        if (outerCurrValue >= outerValue)
        {
            outerCurrValue = outerValue;
            outerTimer->stop();
        }
        else
        {
            outerCurrValue += animationStep;
        }
    }
    else
    {
        if (outerCurrValue <= outerValue)
        {
            outerCurrValue = outerValue;
            outerTimer->stop();
        }
        else
        {
            outerCurrValue -= animationStep;
        }
    }

    this->update();
}

void GaugeWeather::updateInnerValue()
{
    //currValue变成Value的过程
    if(clockWise)
    {
        //针对value大于零时，当currValue 小于 Value，需要回滚，否则前滚，
        if (!innerReverse)
        {
            if (innerCurrValue >= innerValue)
            {
                innerCurrValue = innerValue;
                innerTimer->stop();
            }
            else
            {
                innerCurrValue += animationStep;
            }
        }
        else
        {
            if (innerCurrValue <= innerValue)
            {
                innerCurrValue = innerValue;
                innerTimer->stop();
            }
            else
            {
                innerCurrValue -= animationStep;
            }
        }

    }
    else
    {
        //针对value大于零时，当currValue 大于 Value，需要回滚，否则前滚，
        if (!innerReverse)
        {
            if (innerCurrValue <= innerValue)
            {
                innerCurrValue = innerValue;
                innerTimer->stop();
            }
            else
            {
                innerCurrValue -= animationStep;
            }
        }
        else
        {
            if (innerCurrValue >= innerValue)
            {
                innerCurrValue = innerValue;
                innerTimer->stop();
            }
            else
            {
                innerCurrValue += animationStep;
            }
        }
    }

    this->update();
}