Subversion Repositories tpanel

/*
 * Copyright (C) 2023 by Andreas Theofilu <andreas@theosys.at>
 *
 * 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 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 */
#include <QPainter>
#include <QString>
#include <QStaticText>
#include <QRegion>
#include <QApplication>

#include <vector>
#include <chrono>

#include "tqmarquee.h"
#include "terror.h"

using std::vector;

TQMarquee::TQMarquee(QWidget* parent)
    : QLabel(parent),
      mParent(parent)
{
    DECL_TRACER("TQMarquee::TQMarquee(QWidget* parent)");

    init();
}

TQMarquee::TQMarquee(QWidget* parent, int msec, MQ_TYPES type, bool enable)
    : QLabel(parent),
      mParent(parent),
      mScrollEnabled(enable),
      mType(type)
{
    DECL_TRACER("TQMarquee::TQMarquee(QWidget* parent, int msec, MQ_TYPES type, bool enable)");

    if (msec >= 1 && msec <= 10)
        mInterval = BASE_SPEED - 2 + msec * 2;

    init();
}

TQMarquee::~TQMarquee()
{
    DECL_TRACER("TQMarquee::~TQMarquee()");

    if (mTimer)
    {
        if (mTimer->isActive())
            mTimer->stop();

        delete mTimer;
    }
}

void TQMarquee::init()
{
    DECL_TRACER("TQMarquee::init()");

    switch(mType)
    {
        case MQ_LEFT:   mDirection = Qt::RightToLeft; break;
        case MQ_RIGHT:  mDirection = Qt::LeftToRight; break;

        default:
            mDirection = Qt::RightToLeft;
    }

//    setAutoFillBackground(false);
    mTimer = new QTimer(this);
    mTimer->setTimerType(Qt::CoarseTimer);
    connect(mTimer, &QTimer::timeout, this, &TQMarquee::refreshLabel);
    // By default the background is transparent
    setBackgroundColor(mBgColor);
    mFontPointSize = font().pointSize() / 2;
    mTextLength = fontMetrics().horizontalAdvance(mText);
    mTextHeight = fontMetrics().height();
    mTimer->start(mInterval);
}

void TQMarquee::setAlignment(Qt::Alignment al)
{
    DECL_TRACER("TQMarquee::setAlignment(Qt::Alignment al)");

    mAlign = al;
    updateCoordinates();
}

void TQMarquee::setFrame(int left, int top, int right, int bottom)
{
    DECL_TRACER("TQMarquee::setFrame(int left, int top, int right, int bottom)");

    mFrameLeft = (left > 0 && left < width() ? left : 0);
    mFrameTop = (top > 0 && top < height() ? top : 0);
    mFrameRight = (right > 0 && right < width() ? right : 0);
    mFrameBottom = (bottom > 0 && bottom < height() ? bottom : 0);

    if ((mFrameLeft + mFrameRight) > width())
        mFrameLeft = mFrameRight = 0;

    if ((mFrameTop + mFrameBottom) > height())
        mFrameTop = mFrameBottom = 0;

    update();
}

void TQMarquee::setText(const QString& text)
{
    DECL_TRACER("TQMarquee::setText(const QString& text)");

    mText = text;
    mFontPointSize = font().pointSize() / 2;
    mTextLength = fontMetrics().horizontalAdvance(mText);
    mTextHeight = fontMetrics().height();
    refreshLabel();
    update();
}

void TQMarquee::setFont(const QFont &f)
{
    DECL_TRACER("TQMarquee::setFont(const QFont &font)");

    QLabel::setFont(f);
    mFontPointSize = font().pointSize() / 2;
    mTextLength = fontMetrics().horizontalAdvance(mText);
    mTextHeight = fontMetrics().height();
}

void TQMarquee::setSpeed(int msec)
{
    DECL_TRACER("TQMarquee::setSpeed(int msec)");

    if (msec < 1 || msec > 10)
    {
        MSG_WARNING("Wrong speed " << msec << "! The speed must be between 1 and 10.");
        return;
    }

    if (!mTimer)
    {
        MSG_ERROR("Timer is not initialized!");
        return;
    }

    mInterval = BASE_SPEED - 2 + msec * 2;

    if (mTimer->isActive())
        mTimer->start(mInterval);
    else
        mTimer->setInterval(mInterval);
}

void TQMarquee::pause()
{
    DECL_TRACER("TQMarquee::pause()");

    if (!mTimer)
        return;

    if (mTimer->isActive())
        mTimer->stop();

    mPaused = true;
}

void TQMarquee::resume()
{
    DECL_TRACER("TQMarquee::resume()");

    if (!mTimer)
        return;

    if (!mTimer->isActive())
        mTimer->start(mInterval);

    mPaused = false;
}

QColor TQMarquee::backgroundColor()
{
    DECL_TRACER("TQMarquee::backgroundColor()");

    QPalette::ColorRole colorRole = backgroundRole();
    QBrush brush = palette().brush(colorRole);
    return brush.color();
}

void TQMarquee::setBackgroundColor(QColor& color)
{
    DECL_TRACER("TQMarquee::setBackgroundColor(QColor& color)");

    QBrush brush;
    brush.setColor(color);
    QPalette pal;
    pal.setBrush(backgroundRole(), brush);
    setPalette(pal);
}

QPixmap TQMarquee::background()
{
    DECL_TRACER("TQMarquee::background()");

    return mBackgroundImage;
}

void TQMarquee::setBackground(QPixmap& image)
{
    DECL_TRACER("TQMarquee::setBackground(QPixmap& image)");

    mBackgroundImage = image;
    setPixmap(mBackgroundImage);
    update();
}

void TQMarquee::setDirection(MQ_TYPES type)
{
    DECL_TRACER("TQMarquee::setDirection(MQ_TYPES type)");

    mType = type;

    switch(type)
    {
        case MQ_LEFT:   mDirection = Qt::RightToLeft; break;
        case MQ_RIGHT:  mDirection = Qt::LeftToRight; break;

        default:
            mDirection = Qt::RightToLeft;
    }

    if (mType == MQ_RIGHT || mType == MQ_PONG)
        px = width() - (mTextLength + mFrameLeft + mFrameRight);
    else if (mType == MQ_LEFT)
        px = mFrameLeft;
    else if (mType == MQ_DOWN)
    {
        py = height() - (mTextHeight + mFrameTop + mFrameBottom);
        px = width() / 2 - mTextLength / 2;
    }
    else if (mType == MQ_UP)
    {
        py = mFrameTop;
        px = width() / 2 - mTextLength / 2;
    }

    refreshLabel();
}

void TQMarquee::refreshLabel()
{
//    DECL_TRACER("TQMarquee::refreshLabel()");       // This would fill up a logfile, if there is one.

    update();
}

void TQMarquee::hideEvent(QHideEvent *e)
{
    DECL_TRACER("TQMarquee::hideEvent(QHideEvent*)");

    pause();
    QLabel::hideEvent(e);
}

void TQMarquee::showEvent(QShowEvent *e)
{
    DECL_TRACER("TQMarquee::showEvent(QShowEvent*)");

    resume();
    QLabel::showEvent(e);
}

bool TQMarquee::testVisibility(const QRegion& region)
{
    if (region.isEmpty() || region.isNull())
        return false;

    return true;
}

void TQMarquee::paintEvent(QPaintEvent*)
{
//    DECL_TRACER("TQMarquee::paintEvent(QPaintEvent*)");   // This would fill up a logfile, if there is one.

    if (!testVisibility(visibleRegion()))
        return;

    QPainter p(this);
    p.drawPixmap(0, 0, mBackgroundImage);

    if (mScrollEnabled && !mPaused)
    {
        if(mType == MQ_LEFT)
        {
            px -= mSpeed;

            if(px <= (-mTextLength))
                px = width();
        }
        else if (mType == MQ_RIGHT)
        {
            px += mSpeed;

            if(px >= width())
                px = -mTextLength;
        }
        else if (mType == MQ_PONG)
        {
            if (mDirection == Qt::LeftToRight)
            {
                px -= mSpeed;
                bool changeDirection = false;

                if (mTextLength > width())
                    changeDirection = (px <= (width() - mTextLength - mFrameLeft));
                else
                    changeDirection = (px <= mFrameLeft);

                if (changeDirection)
                    mDirection = Qt::RightToLeft;
            }
            else
            {
                px += mSpeed;
                bool changeDirection = false;

                if (mTextLength > width())
                    changeDirection = (px >= mFrameLeft);
                else
                    changeDirection = (px >= (width() - mTextLength - mFrameRight));

                if (changeDirection)
                    mDirection = Qt::LeftToRight;
            }
        }
        else if (mType == MQ_DOWN)
        {
            py += mSpeed;

            if (py >= height())
                py = -mTextHeight;
        }
        else if (mType == MQ_UP)
        {
            py -= mSpeed;

            if (py <= (-mTextHeight))
                py = height();
        }

        if (mFrameLeft || mFrameRight || mFrameTop || mFrameBottom)
            p.setClipRect(QRect(mFrameLeft, mFrameTop, width() - mFrameLeft - mFrameRight, height() - mFrameBottom - mFrameTop), Qt::ReplaceClip);

        p.drawText(px, py + mFontPointSize, mText);
        p.translate(px,0);
    }
//    else
//        QLabel::setText(mText);
}

void TQMarquee::resizeEvent(QResizeEvent* evt)
{
    DECL_TRACER("TQMarquee::resizeEvent(QResizeEvent* evt)");

    updateCoordinates();
    QLabel::resizeEvent(evt);
}

void TQMarquee::updateCoordinates()
{
    DECL_TRACER("TQMarquee::updateCoordinates()");

//    mFontPointSize = font().pointSize() / 2;
//    mTextLength = fontMetrics().horizontalAdvance(mText);
//    mTextHeight = fontMetrics().height();

    vector<Qt::Alignment> alignList = {
        Qt::AlignLeft, Qt::AlignHCenter, Qt::AlignRight,
        Qt::AlignTop, Qt::AlignVCenter, Qt::AlignBottom };
    vector<Qt::Alignment>::iterator iter;

    for (iter = alignList.begin(); iter != alignList.end(); ++iter)
    {
        bool al = (mAlign & *iter) == *iter;

        if (al)
        {
            switch(*iter)
            {
                case Qt::AlignTop:      py = mFrameTop + mTextHeight / 2; break;
                case Qt::AlignBottom:   py = height() - (mFrameTop + mFrameBottom + mTextHeight / 2); break;
                case Qt::AlignVCenter:  py = height() / 2; break;

                case Qt::AlignLeft:     px = mFrameLeft; break;
                case Qt::AlignRight:    px = width() - mTextLength - mFrameRight; break;
                case Qt::AlignHCenter:  px = width() / 2 - mTextLength / 2; break;

                default:
                    px = width() / 2 - mTextLength / 2;
                    py = height() / 2;
            }
        }
    }
}