547 lines
15 KiB
C++
547 lines
15 KiB
C++
/*
|
|
* Copyright (C) 2007 Petri Damsten <damu@iki.fi>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU Library General Public License as
|
|
* published by the Free Software Foundation; either version 2, 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 Library 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 "meter.h"
|
|
#include "private/meter_p.h"
|
|
|
|
#include <cmath>
|
|
|
|
#include <QPainter>
|
|
#include <QTimeLine>
|
|
#include <QPropertyAnimation>
|
|
|
|
#include <kdebug.h>
|
|
#include <kglobalsettings.h>
|
|
|
|
#include "plasma/animator.h"
|
|
#include "plasma/framesvg.h"
|
|
#include "plasma/theme.h"
|
|
|
|
namespace Plasma {
|
|
|
|
MeterPrivate::MeterPrivate(Meter *m)
|
|
: QObject(m),
|
|
minimum(0),
|
|
maximum(100),
|
|
value(0),
|
|
targetValue(0),
|
|
meterType(Meter::AnalogMeter),
|
|
image(0),
|
|
minrotate(0),
|
|
maxrotate(360),
|
|
meter(m)
|
|
{
|
|
}
|
|
|
|
void MeterPrivate::progressChanged(int progress)
|
|
{
|
|
value = progress;
|
|
meter->update();
|
|
}
|
|
|
|
void MeterPrivate::paint(QPainter *p, const QString &elementID)
|
|
{
|
|
if (image->hasElement(elementID)) {
|
|
QRectF elementRect = image->elementRect(elementID);
|
|
image->paint(p, elementRect, elementID);
|
|
}
|
|
}
|
|
|
|
void MeterPrivate::text(QPainter *p, int index)
|
|
{
|
|
QString elementID = QString("label%1").arg(index);
|
|
QString text = labels[index];
|
|
|
|
if (image->hasElement(elementID)) {
|
|
QRectF elementRect = image->elementRect(elementID);
|
|
Qt::Alignment align = Qt::AlignCenter;
|
|
|
|
if (colors.count() > index) {
|
|
p->setPen(QPen(colors[index]));
|
|
} else {
|
|
p->setPen(Plasma::Theme::defaultTheme()->color(Plasma::Theme::TextColor));
|
|
}
|
|
if (fonts.count() > index) {
|
|
p->setFont(fonts[index]);
|
|
}
|
|
if (alignments.count() > index) {
|
|
align = alignments[index];
|
|
}
|
|
if (elementRect.width() > elementRect.height()) {
|
|
if (align&Qt::AlignLeft) {
|
|
p->drawText(elementRect.bottomLeft(), text);
|
|
} else {
|
|
p->drawText(elementRect, align, text);
|
|
}
|
|
} else {
|
|
p->save();
|
|
QPointF rotateCenter(
|
|
elementRect.left() + elementRect.width() / 2,
|
|
elementRect.top() + elementRect.height() / 2);
|
|
p->translate(rotateCenter);
|
|
p->rotate(-90);
|
|
p->translate(elementRect.height() / -2,
|
|
elementRect.width() / -2);
|
|
QRectF r(0, 0, elementRect.height(), elementRect.width());
|
|
p->drawText(r, align, text);
|
|
p->restore();
|
|
}
|
|
}
|
|
}
|
|
|
|
QRectF MeterPrivate::barRect()
|
|
{
|
|
QRectF elementRect;
|
|
|
|
if (labels.count() > 0) {
|
|
elementRect = image->elementRect("background");
|
|
} else {
|
|
elementRect = QRectF(QPoint(0,0), meter->size());
|
|
}
|
|
|
|
if (image->hasElement("hint-bar-stretch") || !image->hasElement("bar-active-center")) {
|
|
return elementRect;
|
|
}
|
|
|
|
QSize imageSize = image->size();
|
|
image->resize();
|
|
QSize tileSize = image->elementSize("bar-active-center");
|
|
image->resize(imageSize);
|
|
|
|
if (elementRect.width() > elementRect.height()) {
|
|
qreal ratio = qMax(1, tileSize.height() / tileSize.width());
|
|
int numTiles = qMax(qreal(1.0), qreal(elementRect.width())/(qreal(elementRect.height())/ratio));
|
|
tileSize = QSize(elementRect.width()/numTiles, elementRect.height());
|
|
|
|
QPoint center = elementRect.center().toPoint();
|
|
elementRect.setWidth(tileSize.width()*numTiles);
|
|
elementRect.moveCenter(center);
|
|
} else {
|
|
qreal ratio = qMax(1, tileSize.width() / tileSize.height());
|
|
int numTiles = qMax(qreal(1.0), qreal(elementRect.height())/(qreal(elementRect.width())/ratio));
|
|
tileSize = QSize(elementRect.width(), elementRect.height()/numTiles);
|
|
|
|
QPoint center = elementRect.center().toPoint();
|
|
elementRect.setHeight(tileSize.height()*numTiles);
|
|
elementRect.moveCenter(center);
|
|
}
|
|
|
|
return elementRect;
|
|
}
|
|
|
|
void MeterPrivate::paintBackground(QPainter *p)
|
|
{
|
|
//be retrocompatible with themes for kde <= 4.1
|
|
if (image->hasElement("background-center")) {
|
|
QRectF elementRect = barRect();
|
|
if (elementRect.isEmpty()) {
|
|
return; // nothing to be done
|
|
}
|
|
|
|
QSize imageSize = image->size();
|
|
image->resize();
|
|
|
|
image->setElementPrefix("background");
|
|
image->resizeFrame(elementRect.size());
|
|
image->paintFrame(p, elementRect.topLeft());
|
|
image->resize(imageSize);
|
|
|
|
paintBar(p, "bar-inactive");
|
|
} else {
|
|
paint(p, "background");
|
|
}
|
|
}
|
|
|
|
void MeterPrivate::paintBar(QPainter *p, const QString &prefix)
|
|
{
|
|
QRectF elementRect = barRect();
|
|
|
|
image->setUsingRenderingCache(false);
|
|
if (image->hasElement("hint-bar-stretch")) {
|
|
image->resizeFrame(elementRect.size());
|
|
image->paintFrame(p);
|
|
} else {
|
|
QSize imageSize = image->size();
|
|
image->resize();
|
|
QSize tileSize = image->elementSize("bar-active-center");
|
|
|
|
if (elementRect.width() > elementRect.height()) {
|
|
qreal ratio = tileSize.height() / tileSize.width();
|
|
int numTiles = elementRect.width()/(elementRect.height()/ratio);
|
|
tileSize = QSize(elementRect.width()/numTiles, elementRect.height());
|
|
} else {
|
|
qreal ratio = tileSize.width() / tileSize.height();
|
|
int numTiles = elementRect.height()/(elementRect.width()/ratio);
|
|
tileSize = QSize(elementRect.width(), elementRect.height()/numTiles);
|
|
}
|
|
|
|
image->setElementPrefix(prefix);
|
|
image->resizeFrame(tileSize);
|
|
p->drawTiledPixmap(elementRect, image->framePixmap());
|
|
image->resize(imageSize);
|
|
}
|
|
image->setUsingRenderingCache(true);
|
|
}
|
|
|
|
void MeterPrivate::paintForeground(QPainter *p)
|
|
{
|
|
for (int i = 0; i < labels.count(); ++i) {
|
|
text(p, i);
|
|
}
|
|
|
|
paint(p, "foreground");
|
|
}
|
|
|
|
void MeterPrivate::setSizePolicyAndPreferredSize()
|
|
{
|
|
switch (meterType) {
|
|
case Meter::BarMeterHorizontal:
|
|
meter->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Preferred);
|
|
break;
|
|
case Meter::BarMeterVertical:
|
|
meter->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
|
|
break;
|
|
case Meter::AnalogMeter:
|
|
default:
|
|
meter->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
|
|
break;
|
|
}
|
|
|
|
if (image) {
|
|
//set a sane preferredSize. We can't just use the svg's native size, since that way
|
|
//letters get cut off if the user uses a font larger then usual. Check how many rows of
|
|
//labels we have, add 1 (the progress bar), and multiply by the font height to get a
|
|
//somewhat sane size height. This is not perfect but work well enough for 4.2. I suggest
|
|
//we look into alternatives for 4.3.
|
|
uint i = 0;
|
|
uint rows = 0;
|
|
qreal prevY = -1;
|
|
QString labelName = "label0";
|
|
while (image->hasElement(labelName)) {
|
|
if (image->elementRect(labelName).y() > prevY) {
|
|
prevY = image->elementRect(labelName).y();
|
|
rows++;
|
|
}
|
|
i++;
|
|
labelName = QString("label%0").arg(i);
|
|
}
|
|
|
|
Plasma::Theme *theme = Plasma::Theme::defaultTheme();
|
|
QFont font = theme->font(Plasma::Theme::DefaultFont);
|
|
QFontMetrics fm(font);
|
|
|
|
meter->setPreferredHeight((rows + 1) * fm.height());
|
|
} else {
|
|
meter->setPreferredSize(QSizeF(30, 30));
|
|
}
|
|
}
|
|
|
|
Meter::Meter(QGraphicsItem *parent) :
|
|
QGraphicsWidget(parent),
|
|
d(new MeterPrivate(this))
|
|
{
|
|
d->setSizePolicyAndPreferredSize();
|
|
|
|
d->animation = new QPropertyAnimation(d, "meterValue");
|
|
}
|
|
|
|
Meter::~Meter()
|
|
{
|
|
delete d->animation;
|
|
delete d;
|
|
}
|
|
|
|
void Meter::setMaximum(int maximum)
|
|
{
|
|
d->maximum = maximum;
|
|
}
|
|
|
|
int Meter::maximum() const
|
|
{
|
|
return d->maximum;
|
|
}
|
|
|
|
void Meter::setMinimum(int minimum)
|
|
{
|
|
d->minimum = minimum;
|
|
}
|
|
|
|
int Meter::minimum() const
|
|
{
|
|
return d->minimum;
|
|
}
|
|
|
|
int Meter::value() const
|
|
{
|
|
return d->value;
|
|
}
|
|
|
|
void Meter::setValue(int value)
|
|
{
|
|
if (value == d->targetValue) {
|
|
return;
|
|
}
|
|
|
|
d->targetValue = qBound(d->minimum, value, d->maximum);
|
|
int delta = abs(d->value - d->targetValue);
|
|
|
|
if (d->animation->state() != QAbstractAnimation::Running) {
|
|
d->animation->stop();
|
|
}
|
|
|
|
//kDebug() << d->targetValue << d->value << delta;
|
|
if (!(KGlobalSettings::graphicEffectsLevel() & KGlobalSettings::SimpleAnimationEffects) ||
|
|
delta / qreal(d->maximum) < 0.1) {
|
|
d->value = value;
|
|
update();
|
|
} else {
|
|
d->animation->setStartValue(d->value);
|
|
d->animation->setEndValue(value);
|
|
d->animation->start();
|
|
}
|
|
}
|
|
|
|
int MeterPrivate::meterValue() const
|
|
{
|
|
return value;
|
|
}
|
|
|
|
void MeterPrivate::setMeterValue(int value)
|
|
{
|
|
progressChanged(value);
|
|
}
|
|
|
|
void Meter::setLabel(int index, const QString &text)
|
|
{
|
|
while (d->labels.count() <= index) {
|
|
d->labels << QString();
|
|
}
|
|
d->labels[index] = text;
|
|
}
|
|
|
|
QString Meter::label(int index) const
|
|
{
|
|
return d->labels[index];
|
|
}
|
|
|
|
void Meter::setLabelColor(int index, const QColor &color)
|
|
{
|
|
while (d->colors.count() <= index) {
|
|
d->colors << color;
|
|
}
|
|
d->colors[index] = color;
|
|
}
|
|
|
|
QColor Meter::labelColor(int index) const
|
|
{
|
|
return d->colors[index];
|
|
}
|
|
|
|
void Meter::setLabelFont(int index, const QFont &font)
|
|
{
|
|
while (d->fonts.count() <= index) {
|
|
d->fonts << font;
|
|
}
|
|
d->fonts[index] = font;
|
|
}
|
|
|
|
QFont Meter::labelFont(int index) const
|
|
{
|
|
return d->fonts[index];
|
|
}
|
|
|
|
void Meter::setLabelAlignment(int index, const Qt::Alignment alignment)
|
|
{
|
|
while (d->alignments.count() <= index) {
|
|
d->alignments << alignment;
|
|
}
|
|
d->alignments[index] = alignment;
|
|
}
|
|
|
|
Qt::Alignment Meter::labelAlignment(int index) const
|
|
{
|
|
return d->alignments[index];
|
|
}
|
|
|
|
QRectF Meter::labelRect(int index) const
|
|
{
|
|
QString elementID = QString("label%1").arg(index);
|
|
return d->image->elementRect(elementID);
|
|
}
|
|
|
|
void Meter::dataUpdated(const QString &sourceName, const Plasma::DataEngine::Data &data)
|
|
{
|
|
Q_UNUSED(sourceName)
|
|
|
|
foreach (const QVariant &v, data) {
|
|
if (v.type() == QVariant::Int ||
|
|
v.type() == QVariant::UInt ||
|
|
v.type() == QVariant::LongLong ||
|
|
v.type() == QVariant::ULongLong) {
|
|
setValue(v.toInt());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Meter::setSvg(const QString &svg)
|
|
{
|
|
if (d->svg == svg) {
|
|
return;
|
|
}
|
|
|
|
d->svg = svg;
|
|
delete d->image;
|
|
d->image = new Plasma::FrameSvg(this);
|
|
d->image->setImagePath(svg);
|
|
// To create renderer and get default size
|
|
d->image->resize();
|
|
d->setSizePolicyAndPreferredSize();
|
|
if (d->image->hasElement("rotateminmax")) {
|
|
QRectF r = d->image->elementRect("rotateminmax");
|
|
d->minrotate = (int)r.height();
|
|
d->maxrotate = (int)r.width();
|
|
}
|
|
}
|
|
|
|
QString Meter::svg() const
|
|
{
|
|
return d->svg;
|
|
}
|
|
|
|
void Meter::setMeterType(MeterType meterType)
|
|
{
|
|
d->meterType = meterType;
|
|
if (d->svg.isEmpty()) {
|
|
if (meterType == BarMeterHorizontal) {
|
|
setSvg("widgets/bar_meter_horizontal");
|
|
} else if (meterType == BarMeterVertical) {
|
|
setSvg("widgets/bar_meter_vertical");
|
|
} else if (meterType == AnalogMeter) {
|
|
setSvg("widgets/analog_meter");
|
|
}
|
|
}
|
|
d->setSizePolicyAndPreferredSize();
|
|
}
|
|
|
|
Meter::MeterType Meter::meterType() const
|
|
{
|
|
return d->meterType;
|
|
}
|
|
|
|
void Meter::paint(QPainter *p,
|
|
const QStyleOptionGraphicsItem *option,
|
|
QWidget *widget)
|
|
{
|
|
Q_UNUSED(option)
|
|
Q_UNUSED(widget)
|
|
|
|
if (d->svg.isEmpty()) {
|
|
setMeterType(d->meterType);
|
|
}
|
|
|
|
if (!d->image) {
|
|
return;
|
|
}
|
|
|
|
QRectF rect(QPointF(0, 0), size());
|
|
QRectF clipRect;
|
|
qreal percentage = 0.0;
|
|
qreal angle = 0.0;
|
|
QPointF rotateCenter;
|
|
QSize intSize = QSize((int)size().width(), (int)size().height());
|
|
|
|
if (intSize != d->image->size()) {
|
|
d->image->resize(intSize);
|
|
}
|
|
|
|
if (d->maximum != d->minimum) {
|
|
percentage = (qreal)(d->value - d->minimum) / (d->maximum - d->minimum);
|
|
}
|
|
|
|
p->setRenderHint(QPainter::SmoothPixmapTransform);
|
|
switch (d->meterType) {
|
|
case BarMeterHorizontal:
|
|
case BarMeterVertical:
|
|
d->paintBackground(p);
|
|
|
|
p->save();
|
|
clipRect = d->barRect();
|
|
if (clipRect.width() > clipRect.height()) {
|
|
clipRect.setWidth(clipRect.width() * percentage);
|
|
} else {
|
|
qreal bottom = clipRect.bottom();
|
|
clipRect.setHeight(clipRect.height() * percentage);
|
|
clipRect.moveBottom(bottom);
|
|
}
|
|
p->setClipRect(clipRect, Qt::IntersectClip);
|
|
|
|
//be retrocompatible
|
|
if (d->image->hasElement("bar-active-center")) {
|
|
d->paintBar(p, "bar-active");
|
|
} else {
|
|
d->paint(p, "bar");
|
|
}
|
|
p->restore();
|
|
|
|
d->paintForeground(p);
|
|
break;
|
|
case AnalogMeter:
|
|
d->paintBackground(p);
|
|
|
|
p->save();
|
|
if (d->image->hasElement("rotatecenter")) {
|
|
QRectF r = d->image->elementRect("rotatecenter");
|
|
rotateCenter = QPointF(r.left() + r.width() / 2,
|
|
r.top() + r.height() / 2);
|
|
} else {
|
|
rotateCenter = QPointF(rect.width() / 2, rect.height() / 2);
|
|
}
|
|
angle = percentage * (d->maxrotate - d->minrotate) + d->minrotate;
|
|
|
|
if (d->image->hasElement("pointer-shadow")) {
|
|
p->save();
|
|
p->translate(rotateCenter+QPoint(2,3));
|
|
p->rotate(angle);
|
|
p->translate(-1 * rotateCenter);
|
|
d->paint(p, "pointer-shadow");
|
|
p->restore();
|
|
}
|
|
|
|
p->translate(rotateCenter);
|
|
p->rotate(angle);
|
|
p->translate(-1 * rotateCenter);
|
|
d->paint(p, "pointer");
|
|
p->restore();
|
|
|
|
d->paintForeground(p);
|
|
break;
|
|
}
|
|
}
|
|
|
|
QSizeF Meter::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
|
|
{
|
|
return QGraphicsWidget::sizeHint(which, constraint);
|
|
}
|
|
|
|
} // End of namepace
|
|
|
|
#include "meter.moc"
|
|
#include "../private/meter_p.moc"
|