swflipdigit.cpp

/***************************************************************************
 
    source::worx raDIYo
    Copyright © 2020-2022 c.holzheuer
    c.holzheuer@sourceworx.org
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
 
***************************************************************************/
 
/*+
 * contains copy-writen material from qt example code:
 * @see shaped clock example
 * @see embedded/flipdigits example
 *
 * **/
 
 
#include <QWidget>
#include <QtCore>
#include <QPainter>
#include <QFontDatabase>
 
#include <swflipdigit.h>
 
 
SWFlipDigit::SWFlipDigit( QWidget *parent )
    :   QWidget( parent ),
        _number( 0 ),
        _transition( Slide )
{
 
 
    //setAttribute( Qt::WA_OpaquePaintEvent, true );
    setAttribute( Qt::WA_NoSystemBackground, true );
    connect(&_animator, SIGNAL(frameChanged(int)), SLOT(update()));
    _animator.setFrameRange( 0, 100 );
    _animator.setDuration( 600 );
    _animator.setEasingCurve( ( QEasingCurve( QEasingCurve::InOutQuad ) ) );
 
 
}
 
SWFlipDigit::~SWFlipDigit()
{
 
}
 
void SWFlipDigit::setTransition( SWFlipMode tr)
{
    _transition = tr;
}
 
 
SWFlipDigit::SWFlipMode SWFlipDigit::transition() const
{
    return _transition;
}
 
 
void SWFlipDigit::setRange( int from, int to )
{
    _rangeFrom = from;
    _rangeTo = to;
}
 
void SWFlipDigit::setNumber( int n )
{
    if (_number != n) {
        _number = qBound( _rangeFrom, n, _rangeTo );
        preparePixmap();
        update();
    }
}
 
void SWFlipDigit::flipTo( int n )
{
    if (_number != n) {
        _number = qBound( _rangeFrom, n, _rangeTo );
        _lastPixmap = _pixmap;
        preparePixmap();
        _animator.stop();
        _animator.start();
    }
}
 
void SWFlipDigit::drawFrame( QPainter *p, const QRect &rect )
{
    p->setPen(Qt::NoPen);
 
    QLinearGradient gradient(rect.topLeft(), rect.bottomLeft());
    gradient.setColorAt(0.00, QColor(245, 245, 245));
    gradient.setColorAt(0.49, QColor(192, 192, 192));
    gradient.setColorAt(0.51, QColor(245, 245, 245));
    gradient.setColorAt(1.00, QColor(192, 192, 192));
    p->setBrush( gradient );
 
    QRect r = rect;
    p->drawRoundedRect( r, 15, 15, Qt::RelativeSize );
    r.adjust( 1, 4, -1, -4 );
    p->setPen (QColor( 181, 181, 181 ) );
    p->setBrush( Qt::NoBrush );
    p->drawRoundedRect( r, 15, 15, Qt::RelativeSize );
    p->setPen( QColor( 159, 159, 159  ));
    int y = rect.top() + rect.height() / 2 - 1;
    p->drawLine( rect.left(), y, rect.right(), y );
}
 
 
QPixmap SWFlipDigit::drawDigits( int digit, const QRect &rect )
{
 
    QString strDigit = QString::number( digit );
    if( strDigit.length() == 1 )
        strDigit.prepend( '0' );
 
    // FIX!
    QFont font;
 
    //font.setFamily("CorelDraw");
    font.setFamily( "Grado Gradoo Nf" );
    //font.setFamily("Selznick Remix NF");
    //font.setFamily( "Valley Grrrl NF" );
 
    //static const double SWSCALEFACTOR = 2.2;
 
    int fontHeight = SWSCALEFACTOR * SWFONTSCALE * rect.height();
    font.setPixelSize( fontHeight );
    //font.setBold( true );
 
    QPixmap pixmap( rect.size() * SWSCALEFACTOR );
    pixmap.fill( Qt::transparent );
 
    QLinearGradient gradient( QPoint( 0, 0 ), QPoint( 0, pixmap.height() ) );
    gradient.setColorAt( 0.00, QColor(128, 128, 128) );
    gradient.setColorAt( 0.49, QColor(64, 64, 64) );
    gradient.setColorAt( 0.51, QColor(128, 128, 128) );
    gradient.setColorAt( 1.00, QColor(16, 16, 16) );
 
    QPainter painter;
    painter.begin( &pixmap );
    painter.setFont( font );
    QPen pen;
    pen.setBrush( QBrush( gradient ) );
    painter.setPen( pen );
 
    QRect pos = pixmap.rect();
    pos.adjust( 0, -100, 0, 0 );
 
    /*
    painter.drawRect( pixmap.rect() );
    painter.setPen( Qt::darkGray );
    painter.drawRect( pos );
    //painter.setPen( pen );
    */
 
    painter.drawText( pos, Qt::AlignCenter, strDigit );
    painter.end();
 
    return pixmap.scaledToWidth( width(), Qt::SmoothTransformation );
 
}
 
 
void SWFlipDigit::preparePixmap()
{
    _pixmap = QPixmap(size());
    _pixmap.fill(Qt::transparent);
    QPainter painter;
    painter.begin(&_pixmap);
    painter.drawPixmap( 0, 0, drawDigits( _number, rect() ) );
    painter.end();
}
 
 
void SWFlipDigit::resizeEvent(QResizeEvent*)
{
    preparePixmap();
    update();
}
 
 
void SWFlipDigit::paintStatic()
{
    QPainter painter( this );
    painter.fillRect( rect(), Qt::black );
    //painter.fillRect( rect(), Qt::green );
    drawFrame( &painter, rect() );
    painter.drawPixmap( 0, 0, _pixmap );
}
 
 
void SWFlipDigit::paintSlide()
{
    QPainter painter( this );
    painter.fillRect( rect(), Qt::black );
 
    //int pad = SWPADWIDTH;
    //QRect fr = rect().adjusted( pad, pad, -pad, -pad );
    drawFrame( &painter, rect() );
    painter.setClipRect( rect() );
 
    int y = height() * _animator.currentFrame() / 100;
    painter.drawPixmap( 0, y, _lastPixmap );
    painter.drawPixmap( 0, y - height(), _pixmap );
}
 
 
void SWFlipDigit::paintFlip()
{
    QPainter painter( this );
    painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
    painter.setRenderHint(QPainter::Antialiasing, true);
    painter.fillRect(rect(), Qt::black);
 
    int hw = width() / 2;
    int hh = height() / 2;
 
    // behind is the new pixmap
 
   // int pad = SWPADWIDTH;
    QRect fr = rect();//.adjusted( pad, pad, -pad, -pad );
    drawFrame( &painter, fr );
    painter.drawPixmap( 0, 0, _pixmap );
 
    int index = _animator.currentFrame();
 
    if( index <= 50 )
    {
 
        // the top part of the old pixmap is flipping
        int angle = -180 * index / 100;
        QTransform transform;
        transform.translate(hw, hh);
        transform.rotate( angle, Qt::XAxis );
        painter.setTransform(transform);
        drawFrame( &painter, fr.adjusted(-hw, -hh, -hw, -hh ) );
        painter.drawPixmap(-hw, -hh, _lastPixmap);
 
        // the bottom part is still the old pixmap
        painter.resetTransform();
        painter.setClipRect(0, hh, width(), hh);
        drawFrame( &painter, fr );
        painter.drawPixmap( 0, 0, _lastPixmap );
    }
    else
    {
 
        painter.setClipRect( 0, hh, width(), hh );
 
        // the bottom part is still the old pixmap
        drawFrame( &painter, fr );
        painter.drawPixmap(0, 0, _lastPixmap );
 
        // the bottom part of the new pixmap is flipping
        int angle = 180 - 180 * _animator.currentFrame() / 100;
        QTransform transform;
        transform.translate( hw, hh);
        transform.rotate( angle, Qt::XAxis );
        painter.setTransform( transform );
        drawFrame( &painter, fr.adjusted( -hw, -hh, -hw, -hh ) );
        painter.drawPixmap( -hw, -hh, _pixmap );
 
    }
 
}
 
 
void SWFlipDigit::paintRotate()
{
    QPainter p(this);
 
    //int pad = SWPADWIDTH;
    QRect fr = rect();//.adjusted(pad, pad, -pad, -pad);
    drawFrame(&p, fr);
    p.setClipRect(fr);
 
    int angle1 = -180 * _animator.currentFrame() / 100;
    int angle2 = 180 - 180 * _animator.currentFrame() / 100;
    int angle = ( _animator.currentFrame() <= 50 ) ? angle1 : angle2;
    QPixmap pix = ( _animator.currentFrame() <= 50 ) ? _lastPixmap : _pixmap;
 
    QTransform transform;
    transform.translate( width() / 2, height() / 2 );
    transform.rotate( angle, Qt::XAxis );
 
    p.setTransform(transform);
    p.setRenderHint( QPainter::SmoothPixmapTransform, true );
    p.drawPixmap(-width() / 2, -height() / 2, pix);
}
 
 
void SWFlipDigit::paintEvent( QPaintEvent *event )
{
    Q_UNUSED( event );
 
    if (_animator.state() == QTimeLine::Running)
    {
        if(_transition == Slide )
            paintSlide();
        if(_transition == Flip )
            paintFlip();
        if(_transition == Rotate )
            paintRotate();
    }
    else
    {
        paintStatic();
    }
 
}