qskinny/examples/iot-dashboard/LightIntensity.cpp

/****************************************************************************
**
** Copyright 2021 Edelhirsch Software GmbH. All rights reserved.
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are
** met:
**
**   * Redistributions of source code must retain the above copyright
**     notice, this list of conditions and the following disclaimer.
**   * Redistributions in binary form must reproduce the above copyright
**     notice, this list of conditions and the following disclaimer in
**     the documentation and/or other materials provided with the
**     distribution.
**   * Neither the name of the copyright holder nor the names of its
**     contributors may be used to endorse or promote products derived
**     from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**
****************************************************************************/

#include "LightIntensity.h"
#include "Skin.h"

#include <QskAnimator.h>
#include <QskRgbValue.h>
#include <QskSetup.h>
#include <QskTextLabel.h>

#include <QGuiApplication>
#include <QQuickWindow>
#include <QPainter>
#include <QRadialGradient>

QSK_SUBCONTROL( LightIntensityValueLabel, Text )

QSK_SUBCONTROL( LightDisplay, Panel )
QSK_SUBCONTROL( LightDisplay, ColdPart )
QSK_SUBCONTROL( LightDisplay, WarmPart )

namespace
{
    QColor invertedColor( const QColor& c )
    {
        QColor ret = { 255 - c.red(), 255 - c.green(), 255 - c.blue()};
        return ret;
    }
}

// ### There must be an easier way to do this
class DimmerAnimator : public QskAnimator
{
    public:
        DimmerAnimator( LightDisplay* display, LightDimmer* dimmer )
            : m_display( display )
            , m_dimmer( dimmer )
        {
            QQuickWindow* w = static_cast<QQuickWindow*>( qGuiApp->allWindows().at( 0 ) );
            setWindow( w );
            setDuration( 500 );
            setEasingCurve( QEasingCurve::Linear );
            setAutoRepeat( false );
        }

        void setup() override
        {
            m_backgroundColor = m_display->color( LightDisplay::Panel );
            m_ringGradient = m_dimmer->ringGradient();
        }

        void advance( qreal value ) override
        {
            const QColor c = m_backgroundColor;
            const QColor c2 = invertedColor( c );
            const QColor newColor = QskRgb::interpolated( c2, c, value );
            m_dimmer->setBackgroundColor( newColor );

            QRadialGradient gradient = m_ringGradient;
            QRadialGradient newGradient = gradient;

            for( const QGradientStop& stop : gradient.stops() )
            {
                QColor c = stop.second;
                QColor c2 = invertedColor( c );
                const QColor newColor = QskRgb::interpolated( c, c2, value );
                newGradient.setColorAt( stop.first, newColor );
            }

            m_dimmer->setRingGradient( newGradient );
            m_dimmer->update();
        }

    private:
        QColor m_backgroundColor;
        QRadialGradient m_ringGradient;
        LightDisplay* m_display;
        LightDimmer* m_dimmer;
};

LightDimmer::LightDimmer( const QskGradient& coldGradient, const QskGradient& warmGradient, QQuickItem* parent )
    : QQuickPaintedItem( parent )
    , m_coldGradient( coldGradient )
    , m_warmGradient( warmGradient )
{
    connect( this, &QQuickPaintedItem::contentsSizeChanged, [this]()
    {
        auto size = contentsSize();
        QRadialGradient ringGradient( size.width() / 2, size.height() / 2, 110 );
        QGradientStop stop1( 0.0, "#c0c0c0" );
        QGradientStop stop2( 0.5, "#f0f0f0" );
        QGradientStop stop3( 1.0, "#c0c0c0" );
        ringGradient.setStops( {stop1, stop2, stop3} );

        m_ringGradient = ringGradient;
    } );
}

void LightDimmer::paint( QPainter* painter )
{
    const qreal knobDiameter = 15.65;
    const qreal offset = ( thickness() - knobDiameter ) + 2;

    painter->setRenderHint( QPainter::Antialiasing, true );

    auto size = contentsSize();
    QRectF outerRect( {0, offset}, size );

    painter->setBrush( m_ringGradient );

    painter->setPen( m_backgroundColor );
    painter->drawEllipse( outerRect );

    int startAngle = 16 * 180;
    int middleAngle = 16 * -90;
    int endAngle = 16 * -90;

    QLinearGradient coldGradient( {thickness(), 0.0}, {thickness(), thickness()} );
    coldGradient.setColorAt( 0, m_coldGradient.colorAt( 0 ) );
    coldGradient.setColorAt( 1, m_coldGradient.colorAt( 1 ) );
    painter->setBrush( coldGradient );
    painter->setPen( Qt::transparent );
    painter->drawPie( outerRect, startAngle, middleAngle );

    QLinearGradient warmGradient( {thickness(), 0.0}, {thickness(), thickness()} );
    warmGradient.setColorAt( 0, m_warmGradient.colorAt( 0 ) );
    warmGradient.setColorAt( 1, m_warmGradient.colorAt( 1 ) );
    painter->setBrush( warmGradient );
    painter->drawPie( outerRect, 16 * 90, endAngle );

    painter->setBrush( m_backgroundColor );
    painter->setPen( m_backgroundColor );
    QRectF innerRect( thickness() / 2, thickness() / 2 + offset, size.width() - thickness(), size.height() - thickness() );
    painter->drawEllipse( innerRect );

    painter->setBrush( m_backgroundColor );
    painter->setPen( "#c4c4c4" );
    QRectF knobRect( ( contentsSize().width() - knobDiameter ) / 2, 1, knobDiameter, knobDiameter );
    painter->drawEllipse( knobRect );
}

LightDisplay::LightDisplay( QQuickItem* parent )
    : QskControl( parent )
    , m_leftLabel( new QskTextLabel( QString::number( 0 ), this ) )
    , m_centreLabel( new LightIntensityValueLabel( QString::number( 50 ) + "%", this ) )
    , m_rightLabel( new QskTextLabel( QString::number( 100 ), this ) )
    , m_dimmer( new LightDimmer( gradientHint( ColdPart ), gradientHint( WarmPart ), this ) )
    , m_animator( new DimmerAnimator( this, m_dimmer ) )
{
    m_leftLabel->setSizePolicy( Qt::Horizontal, QskSizePolicy::Maximum );
    m_centreLabel->setSizePolicy( Qt::Horizontal, QskSizePolicy::Maximum );
    m_centreLabel->setZ( 1 );
    m_rightLabel->setSizePolicy( Qt::Horizontal, QskSizePolicy::Maximum );
    m_rightLabel->setZ( 1 );

    setAutoLayoutChildren( true );

    const QColor c = color( Panel );
    m_dimmer->setBackgroundColor( c );

    connect( qskSetup, &QskSetup::skinChanged, [this]()
    {
        m_animator->start();
    } );
}

QskAspect::Subcontrol LightDisplay::effectiveSubcontrol( QskAspect::Subcontrol subControl ) const
{
    if( subControl == QskBox::Panel )
    {
        return LightDisplay::Panel;
    }

    return subControl;
}

void LightDisplay::updateLayout()
{
    const qreal w = width() - ( m_leftLabel->width() + m_rightLabel->width() );
    const int r = qMin( w, height() );
    m_dimmer->setContentsSize( {r - 4, r - 4} ); // for some reason we need some padding, hence the 4
    m_dimmer->setSize( QSizeF( r, r ) );
    const qreal padding = 8;
    const qreal x = ( width() - ( m_leftLabel->width() + 2 * padding + m_dimmer->width() + m_rightLabel->width() ) ) / 2;
    const qreal offset = 2; // circle doesn't start at 0
    m_leftLabel->setPosition( {x, ( m_dimmer->height() - m_leftLabel->height() ) / 2 + offset} );

    m_dimmer->setPosition( {m_leftLabel->x() + m_leftLabel->width() + padding, 0} );

    qreal centreX = m_dimmer->x() + ( m_dimmer->width() - m_centreLabel->width() ) / 2;
    qreal centreY = m_dimmer->y() + ( m_dimmer->height() - m_centreLabel->height() ) / 2;
    m_centreLabel->setPosition( {centreX, centreY + offset} );

    m_rightLabel->setPosition( {m_dimmer->x() + m_dimmer->width() + padding, m_leftLabel->y()} );
}

LightIntensity::LightIntensity( QQuickItem* parent )
    : Box( "Light intensity", parent )
{
    new LightDisplay( this );
}