From 553a66b326d0378fba523b09c416bf751ca806cb Mon Sep 17 00:00:00 2001 From: Adriaan de Groot Date: Tue, 19 Sep 2017 12:58:35 +0200 Subject: [PATCH] Licensing: re-import QtWaitingSpinner - include full license headers, - copied from - repo: https://github.com/snowwlex/QtWaitingSpinner - rev: bb8f8987ca19406dc75704eb382ab52e981b773f This revision *does not build* because the files have been renamed. --- LICENSES/MIT-QtWaitingSpinner | 21 ++ .../widgets/QtWaitingSpinner.cpp | 176 ----------- src/libcalamaresui/widgets/QtWaitingSpinner.h | 82 ------ .../widgets/waitingspinnerwidget.cpp | 277 ++++++++++++++++++ .../widgets/waitingspinnerwidget.h | 114 +++++++ 5 files changed, 412 insertions(+), 258 deletions(-) create mode 100644 LICENSES/MIT-QtWaitingSpinner delete mode 100644 src/libcalamaresui/widgets/QtWaitingSpinner.cpp delete mode 100644 src/libcalamaresui/widgets/QtWaitingSpinner.h create mode 100644 src/libcalamaresui/widgets/waitingspinnerwidget.cpp create mode 100644 src/libcalamaresui/widgets/waitingspinnerwidget.h diff --git a/LICENSES/MIT-QtWaitingSpinner b/LICENSES/MIT-QtWaitingSpinner new file mode 100644 index 000000000..c85c97aeb --- /dev/null +++ b/LICENSES/MIT-QtWaitingSpinner @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Original Work Copyright (c) 2012-2015 Alexander Turkin +Modified 2014 by William Hallatt + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/src/libcalamaresui/widgets/QtWaitingSpinner.cpp b/src/libcalamaresui/widgets/QtWaitingSpinner.cpp deleted file mode 100644 index 18c6264bd..000000000 --- a/src/libcalamaresui/widgets/QtWaitingSpinner.cpp +++ /dev/null @@ -1,176 +0,0 @@ -/* === This file is part of Calamares - === - * - * Copyright 2014, Teo Mrnjavac - * - * Originally from https://github.com/snowwlex/QtWaitingSpinner - * Copyright 2012, Alex Turkin - * - * Calamares 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. - * - * Calamares 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 Calamares. If not, see . - */ - -#include -#include - -#include - -#include "QtWaitingSpinner.h" - -QtWaitingSpinner::QtWaitingSpinner(int linesNumber, int length, int width, int radius, QWidget* parent) : QWidget(parent), - myLinesNumber(linesNumber), - myLength(length + width), - myWidth(width), - myRadius(radius), - myRoundness(70.0), - myColor(Qt::black), - mySpeed(1), - myTrail(70), - myOpacity(15) -{ - myCurrentCounter = 0; - myTimer = new QTimer(this); - connect(myTimer,SIGNAL(timeout()), this, SLOT(rotate())); - updateSize(); - updateTimer(); - this->hide(); -} - -void QtWaitingSpinner::paintEvent(QPaintEvent* /*ev*/) { - QPainter painter(this); - painter.fillRect(this->rect(), Qt::transparent); - painter.setRenderHint(QPainter::Antialiasing, true); - - if (myCurrentCounter >= myLinesNumber) { - myCurrentCounter = 0; - } - painter.setPen(Qt::NoPen); - for (int i = 0; i < myLinesNumber; ++i) { - painter.save(); - painter.translate(myRadius + myLength, myRadius + myLength); - qreal rotateAngle = 360.0 * qreal(i) / qreal(myLinesNumber); - painter.rotate(rotateAngle); - painter.translate(myRadius, 0); - int distance = lineDistance(i, myCurrentCounter, myLinesNumber); - QColor color = countTrailColor(distance, myLinesNumber, myTrail, myOpacity, myColor); - painter.setBrush(color); - //TODO improve the way rounded rect is painted - painter.drawRoundedRect(QRect(0, -myWidth/2, myLength, myWidth), myRoundness, myRoundness, Qt::RelativeSize); - painter.restore(); - } -} - -void QtWaitingSpinner::start() { - this->show(); - if (!myTimer->isActive()) { - myTimer->start(); - myCurrentCounter = 0; - } -} - -void QtWaitingSpinner::finish() { - this->hide(); - if (myTimer->isActive()) { - myTimer->stop(); - myCurrentCounter = 0; - } -} - -void QtWaitingSpinner::setLinesNumber(int linesNumber) { - myLinesNumber = linesNumber; - myCurrentCounter = 0; - updateTimer(); -} - -void QtWaitingSpinner::setLength(int length){ - myLength = length; - updateSize(); -} - -void QtWaitingSpinner::setWidth(int width) { - myWidth = width; - updateSize(); -} - -void QtWaitingSpinner::setRadius(int radius) { - myRadius = radius; - updateSize(); -} - -void QtWaitingSpinner::setRoundness(qreal roundness) { - myRoundness = std::max(0.0, std::min(100.0, roundness)); -} - -void QtWaitingSpinner::setColor(QColor color) { - myColor = color; -} - -void QtWaitingSpinner::setSpeed(qreal speed) { - mySpeed = speed; - updateTimer(); -} - -void QtWaitingSpinner::setTrail(int trail) { - myTrail = trail; -} - -void QtWaitingSpinner::setOpacity(int minOpacity) { - myOpacity = minOpacity; -} - -void QtWaitingSpinner::rotate() { - ++myCurrentCounter; - if (myCurrentCounter >= myLinesNumber) { - myCurrentCounter = 0; - } - update(); -} - -void QtWaitingSpinner::updateSize() { - int size = (myRadius + myLength) * 2; - setFixedSize(size, size); -} - -void QtWaitingSpinner::updateTimer() { - myTimer->setInterval(countTimeout(myLinesNumber, mySpeed)); -} - -int QtWaitingSpinner::countTimeout(int lines, qreal speed) { - return int( 1000.0 / (lines * speed) ); -} - -int QtWaitingSpinner::lineDistance(int from, int to, int lines) { - int result = to - from; - if (result < 0) { - result += lines; - } - return result; -} - -QColor QtWaitingSpinner::countTrailColor(int distance, int lines, int trail, int minOpacity, QColor color) { - if (distance == 0) { - return color; - } - const qreal minAlphaF = qreal(minOpacity) / 100.0; - int distanceThreshold = int( ceil( (lines - 1) * qreal(trail) / 100.0) ); - if (distance > distanceThreshold) { - color.setAlphaF(minAlphaF); - return color; - } - qreal alphaDiff = color.alphaF() - minAlphaF; - qreal gradation = alphaDiff / qreal(distanceThreshold + 1); - qreal resultAlpha = color.alphaF() - gradation * distance; - resultAlpha = std::min(1.0, std::max(0.0, resultAlpha)); //if alpha is out of bound, force it to bounds - color.setAlphaF(resultAlpha); - return color; -} - diff --git a/src/libcalamaresui/widgets/QtWaitingSpinner.h b/src/libcalamaresui/widgets/QtWaitingSpinner.h deleted file mode 100644 index 1c1b3eb10..000000000 --- a/src/libcalamaresui/widgets/QtWaitingSpinner.h +++ /dev/null @@ -1,82 +0,0 @@ -/* === This file is part of Calamares - === - * - * Copyright 2014, Teo Mrnjavac - * - * Originally from https://github.com/snowwlex/QtWaitingSpinner - * Copyright 2012, Alex Turkin - * - * Calamares 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. - * - * Calamares 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 Calamares. If not, see . - */ - -#ifndef QTWAITINGSPINNER_H -#define QTWAITINGSPINNER_H - -#include "UiDllMacro.h" - -#include - -#include -#include - -class UIDLLEXPORT QtWaitingSpinner : public QWidget { - Q_OBJECT - -public: - explicit QtWaitingSpinner(int linesNumber = 12, int length = 7, int width = 5, int radius = 10, QWidget* parent = nullptr); - -public Q_SLOTS: - void start(); - void finish(); - -public: - void setLinesNumber(int linesNumber); - void setLength(int length); - void setWidth(int width); - void setRadius(int radius); - void setRoundness(qreal roundness); - void setColor(QColor color); - void setSpeed(qreal speed); - void setTrail(int trail); - void setOpacity(int minOpacity); - -private Q_SLOTS: - void rotate(); - void updateSize(); - void updateTimer(); - -protected: - void paintEvent(QPaintEvent* ev); - -private: - static int countTimeout(int lines, qreal speed); - static int lineDistance(int from, int to, int lines); - static QColor countTrailColor(int distance, int lines, int trail, int minOpacity, QColor color); - -private: - int myLinesNumber; - int myLength; - int myWidth; - int myRadius; - qreal myRoundness; //0..100 - QColor myColor; - qreal mySpeed; // in rounds per second - int myTrail; - int myOpacity; - -private: - QTimer* myTimer; - int myCurrentCounter; -}; - -#endif // QTWAITINGSPINNER_H diff --git a/src/libcalamaresui/widgets/waitingspinnerwidget.cpp b/src/libcalamaresui/widgets/waitingspinnerwidget.cpp new file mode 100644 index 000000000..0ef03a0ba --- /dev/null +++ b/src/libcalamaresui/widgets/waitingspinnerwidget.cpp @@ -0,0 +1,277 @@ +/* Original Work Copyright (c) 2012-2014 Alexander Turkin + Modified 2014 by William Hallatt + Modified 2015 by Jacob Dawid + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +// Own includes +#include "waitingspinnerwidget.h" + +// Standard includes +#include +#include + +// Qt includes +#include +#include + +WaitingSpinnerWidget::WaitingSpinnerWidget(QWidget *parent, + bool centerOnParent, + bool disableParentWhenSpinning) + : QWidget(parent), + _centerOnParent(centerOnParent), + _disableParentWhenSpinning(disableParentWhenSpinning) { + initialize(); +} + +WaitingSpinnerWidget::WaitingSpinnerWidget(Qt::WindowModality modality, + QWidget *parent, + bool centerOnParent, + bool disableParentWhenSpinning) + : QWidget(parent, Qt::Dialog | Qt::FramelessWindowHint), + _centerOnParent(centerOnParent), + _disableParentWhenSpinning(disableParentWhenSpinning){ + initialize(); + + // We need to set the window modality AFTER we've hidden the + // widget for the first time since changing this property while + // the widget is visible has no effect. + setWindowModality(modality); + setAttribute(Qt::WA_TranslucentBackground); +} + +void WaitingSpinnerWidget::initialize() { + _color = Qt::black; + _roundness = 100.0; + _minimumTrailOpacity = 3.14159265358979323846; + _trailFadePercentage = 80.0; + _revolutionsPerSecond = 1.57079632679489661923; + _numberOfLines = 20; + _lineLength = 10; + _lineWidth = 2; + _innerRadius = 10; + _currentCounter = 0; + _isSpinning = false; + + _timer = new QTimer(this); + connect(_timer, SIGNAL(timeout()), this, SLOT(rotate())); + updateSize(); + updateTimer(); + hide(); +} + +void WaitingSpinnerWidget::paintEvent(QPaintEvent *) { + updatePosition(); + QPainter painter(this); + painter.fillRect(this->rect(), Qt::transparent); + painter.setRenderHint(QPainter::Antialiasing, true); + + if (_currentCounter >= _numberOfLines) { + _currentCounter = 0; + } + + painter.setPen(Qt::NoPen); + for (int i = 0; i < _numberOfLines; ++i) { + painter.save(); + painter.translate(_innerRadius + _lineLength, + _innerRadius + _lineLength); + qreal rotateAngle = + static_cast(360 * i) / static_cast(_numberOfLines); + painter.rotate(rotateAngle); + painter.translate(_innerRadius, 0); + int distance = + lineCountDistanceFromPrimary(i, _currentCounter, _numberOfLines); + QColor color = + currentLineColor(distance, _numberOfLines, _trailFadePercentage, + _minimumTrailOpacity, _color); + painter.setBrush(color); + // TODO improve the way rounded rect is painted + painter.drawRoundedRect( + QRect(0, -_lineWidth / 2, _lineLength, _lineWidth), _roundness, + _roundness, Qt::RelativeSize); + painter.restore(); + } +} + +void WaitingSpinnerWidget::start() { + updatePosition(); + _isSpinning = true; + show(); + + if(parentWidget() && _disableParentWhenSpinning) { + parentWidget()->setEnabled(false); + } + + if (!_timer->isActive()) { + _timer->start(); + _currentCounter = 0; + } +} + +void WaitingSpinnerWidget::stop() { + _isSpinning = false; + hide(); + + if(parentWidget() && _disableParentWhenSpinning) { + parentWidget()->setEnabled(true); + } + + if (_timer->isActive()) { + _timer->stop(); + _currentCounter = 0; + } +} + +void WaitingSpinnerWidget::setNumberOfLines(int lines) { + _numberOfLines = lines; + _currentCounter = 0; + updateTimer(); +} + +void WaitingSpinnerWidget::setLineLength(int length) { + _lineLength = length; + updateSize(); +} + +void WaitingSpinnerWidget::setLineWidth(int width) { + _lineWidth = width; + updateSize(); +} + +void WaitingSpinnerWidget::setInnerRadius(int radius) { + _innerRadius = radius; + updateSize(); +} + +QColor WaitingSpinnerWidget::color() { + return _color; +} + +qreal WaitingSpinnerWidget::roundness() { + return _roundness; +} + +qreal WaitingSpinnerWidget::minimumTrailOpacity() { + return _minimumTrailOpacity; +} + +qreal WaitingSpinnerWidget::trailFadePercentage() { + return _trailFadePercentage; +} + +qreal WaitingSpinnerWidget::revolutionsPersSecond() { + return _revolutionsPerSecond; +} + +int WaitingSpinnerWidget::numberOfLines() { + return _numberOfLines; +} + +int WaitingSpinnerWidget::lineLength() { + return _lineLength; +} + +int WaitingSpinnerWidget::lineWidth() { + return _lineWidth; +} + +int WaitingSpinnerWidget::innerRadius() { + return _innerRadius; +} + +bool WaitingSpinnerWidget::isSpinning() const { + return _isSpinning; +} + +void WaitingSpinnerWidget::setRoundness(qreal roundness) { + _roundness = std::max(0.0, std::min(100.0, roundness)); +} + +void WaitingSpinnerWidget::setColor(QColor color) { + _color = color; +} + +void WaitingSpinnerWidget::setRevolutionsPerSecond(qreal revolutionsPerSecond) { + _revolutionsPerSecond = revolutionsPerSecond; + updateTimer(); +} + +void WaitingSpinnerWidget::setTrailFadePercentage(qreal trail) { + _trailFadePercentage = trail; +} + +void WaitingSpinnerWidget::setMinimumTrailOpacity(qreal minimumTrailOpacity) { + _minimumTrailOpacity = minimumTrailOpacity; +} + +void WaitingSpinnerWidget::rotate() { + ++_currentCounter; + if (_currentCounter >= _numberOfLines) { + _currentCounter = 0; + } + update(); +} + +void WaitingSpinnerWidget::updateSize() { + int size = (_innerRadius + _lineLength) * 2; + setFixedSize(size, size); +} + +void WaitingSpinnerWidget::updateTimer() { + _timer->setInterval(1000 / (_numberOfLines * _revolutionsPerSecond)); +} + +void WaitingSpinnerWidget::updatePosition() { + if (parentWidget() && _centerOnParent) { + move(parentWidget()->width() / 2 - width() / 2, + parentWidget()->height() / 2 - height() / 2); + } +} + +int WaitingSpinnerWidget::lineCountDistanceFromPrimary(int current, int primary, + int totalNrOfLines) { + int distance = primary - current; + if (distance < 0) { + distance += totalNrOfLines; + } + return distance; +} + +QColor WaitingSpinnerWidget::currentLineColor(int countDistance, int totalNrOfLines, + qreal trailFadePerc, qreal minOpacity, + QColor color) { + if (countDistance == 0) { + return color; + } + const qreal minAlphaF = minOpacity / 100.0; + int distanceThreshold = + static_cast(ceil((totalNrOfLines - 1) * trailFadePerc / 100.0)); + if (countDistance > distanceThreshold) { + color.setAlphaF(minAlphaF); + } else { + qreal alphaDiff = color.alphaF() - minAlphaF; + qreal gradient = alphaDiff / static_cast(distanceThreshold + 1); + qreal resultAlpha = color.alphaF() - gradient * countDistance; + + // If alpha is out of bounds, clip it. + resultAlpha = std::min(1.0, std::max(0.0, resultAlpha)); + color.setAlphaF(resultAlpha); + } + return color; +} diff --git a/src/libcalamaresui/widgets/waitingspinnerwidget.h b/src/libcalamaresui/widgets/waitingspinnerwidget.h new file mode 100644 index 000000000..8129718a5 --- /dev/null +++ b/src/libcalamaresui/widgets/waitingspinnerwidget.h @@ -0,0 +1,114 @@ +/* Original Work Copyright (c) 2012-2014 Alexander Turkin + Modified 2014 by William Hallatt + Modified 2015 by Jacob Dawid +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#pragma once + +// Qt includes +#include +#include +#include + +class WaitingSpinnerWidget : public QWidget { + Q_OBJECT +public: + /*! Constructor for "standard" widget behaviour - use this + * constructor if you wish to, e.g. embed your widget in another. */ + WaitingSpinnerWidget(QWidget *parent = 0, + bool centerOnParent = true, + bool disableParentWhenSpinning = true); + + /*! Constructor - use this constructor to automatically create a modal + * ("blocking") spinner on top of the calling widget/window. If a valid + * parent widget is provided, "centreOnParent" will ensure that + * QtWaitingSpinner automatically centres itself on it, if not, + * "centreOnParent" is ignored. */ + WaitingSpinnerWidget(Qt::WindowModality modality, + QWidget *parent = 0, + bool centerOnParent = true, + bool disableParentWhenSpinning = true); + +public slots: + void start(); + void stop(); + +public: + void setColor(QColor color); + void setRoundness(qreal roundness); + void setMinimumTrailOpacity(qreal minimumTrailOpacity); + void setTrailFadePercentage(qreal trail); + void setRevolutionsPerSecond(qreal revolutionsPerSecond); + void setNumberOfLines(int lines); + void setLineLength(int length); + void setLineWidth(int width); + void setInnerRadius(int radius); + void setText(QString text); + + QColor color(); + qreal roundness(); + qreal minimumTrailOpacity(); + qreal trailFadePercentage(); + qreal revolutionsPersSecond(); + int numberOfLines(); + int lineLength(); + int lineWidth(); + int innerRadius(); + + bool isSpinning() const; + +private slots: + void rotate(); + +protected: + void paintEvent(QPaintEvent *paintEvent); + +private: + static int lineCountDistanceFromPrimary(int current, int primary, + int totalNrOfLines); + static QColor currentLineColor(int distance, int totalNrOfLines, + qreal trailFadePerc, qreal minOpacity, + QColor color); + + void initialize(); + void updateSize(); + void updateTimer(); + void updatePosition(); + +private: + QColor _color; + qreal _roundness; // 0..100 + qreal _minimumTrailOpacity; + qreal _trailFadePercentage; + qreal _revolutionsPerSecond; + int _numberOfLines; + int _lineLength; + int _lineWidth; + int _innerRadius; + +private: + WaitingSpinnerWidget(const WaitingSpinnerWidget&); + WaitingSpinnerWidget& operator=(const WaitingSpinnerWidget&); + + QTimer *_timer; + bool _centerOnParent; + bool _disableParentWhenSpinning; + int _currentCounter; + bool _isSpinning; +};