void QGraphicsVideoItemPrivate::updateRects()
{
q_ptr->prepareGeometryChange();
if (nativeSize.isEmpty()) {
//this is necessary for item to receive the
//first paint event and configure video surface.
boundingRect = rect;
} else if (aspectRatioMode == Qt::IgnoreAspectRatio) {
boundingRect = rect;
sourceRect = QRectF(0, 0, 1, 1);
} else if (aspectRatioMode == Qt::KeepAspectRatio) {
QSizeF size = nativeSize;
size.scale(rect.size(), Qt::KeepAspectRatio);
boundingRect = QRectF(0, 0, size.width(), size.height());
boundingRect.moveCenter(rect.center());
sourceRect = QRectF(0, 0, 1, 1);
} else if (aspectRatioMode == Qt::KeepAspectRatioByExpanding) {
boundingRect = rect;
QSizeF size = rect.size();
size.scale(nativeSize, Qt::KeepAspectRatio);
sourceRect = QRectF(
0, 0, size.width() / nativeSize.width(), size.height() / nativeSize.height());
sourceRect.moveCenter(QPointF(0.5, 0.5));
}
}
void Guideline::rangeOfAttachedObjects(double& min, double& max) const
{
min = DBL_MAX;
max = -DBL_MAX;
for (RelsList::const_iterator curr = relationships.begin(); curr != relationships.end(); ++curr)
{
QRectF itemRect;
if ((*curr)->shape)
{
itemRect = (*curr)->shape->boundingRect();
itemRect.moveCenter((*curr)->shape->pos());
}
else if ((*curr)->distro)
{
itemRect = (*curr)->distro->boundingRect();
itemRect.moveCenter((*curr)->distro->pos());
}
else if ((*curr)->separation)
{
itemRect = (*curr)->separation->boundingRect();
itemRect.moveCenter((*curr)->separation->pos());
}
if (itemRect.isValid())
{
if (get_dir() == GUIDE_TYPE_HORI)
{
min = qMin(min, itemRect.left());
max = qMax(max, itemRect.right());
}
else
{
min = qMin(min, itemRect.top());
max = qMax(max, itemRect.bottom());
}
}
}
// Cope with the case where there are no attached objects.
if ((min == DBL_MAX) && (max = -DBL_MAX) && canvas())
{
QRectF sceneBounds = canvas()->combinedViewsRect();
if (get_dir() == GUIDE_TYPE_HORI)
{
min = sceneBounds.left();
max = sceneBounds.right();
}
else
{
min = sceneBounds.top();
max = sceneBounds.bottom();
}
}
}
void ScreenRuler::paintEvent(QPaintEvent * event)
{
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing);
// --- brush 1 ----
QBrush brush(painter.brush());
brush.setColor(QColor(Qt::yellow));
// --- brush 2 ----
//QRadialGradient gradient(50, 50, 50, 50, 50);
//gradient.setColorAt(0, QColor::fromRgbF(0, 1, 0, 1));
//gradient.setColorAt(1, QColor::fromRgbF(0, 0, 0, 0));
//QBrush brush(gradient);
painter.setBrush(brush);
painter.fillRect(0, 0, width(),height(), QColor(Qt::yellow));
//»Íâ¿ò
QPen pen(painter.pen());
pen.setStyle(Qt::SolidLine);
pen.setWidth(2);
pen.setBrush(Qt::darkGreen);
painter.setPen(pen);
painter.drawPath(m_framePath);
//»¿Ì¶ÈÏß
pen.setWidth(1);
pen.setBrush(Qt::black);
painter.setPen(pen);
painter.drawPath(m_graduationPath);
//»¿Ì¶ÈÎÄ×Ö
QRectF rectText = QRectF(0, 0, 1000, 1000);
for (int i=0; i<m_textPos.size(); i++)
{
rectText.moveCenter(m_textPos[i]);
painter.drawText(rectText, Qt::AlignCenter, QString(tr("%1").arg(i)));
}
//
if (m_bHorizontalRuler)
{
rectText.moveCenter(QPointF(width()/2, height()*3/4));
painter.drawText(rectText, Qt::AlignCenter, m_rulerDescription + tr(" Unit: cm"));
}
else
{
rectText.moveCenter(QPointF(width()/2, height()*3/4));
painter.drawText(rectText, Qt::AlignCenter, tr("Unit: cm"));
}
}
/**
* Calculates and draws a cross inside an ellipse
* @param p Pointer to a QPainter object.
* @param r The rectangle describing the ellipse.
*/
void drawCrossInEllipse(QPainter *p, const QRectF& r)
{
QRectF ellipse = r;
ellipse.moveCenter(QPointF(0, 0));
qreal a = ellipse.width() * 0.5;
qreal b = ellipse.height() * .5;
qreal xc = ellipse.center().x();
qreal yc = ellipse.center().y();
// The first point's x value is chosen to be center.x() + 70% of x radius.
qreal x1 = ellipse.center().x() + .7 * .5 * ellipse.width();
// Calculate y1 corresponding to x1 using formula.
qreal y1_sqr = b*b*(1 - (x1 * x1) / (a*a));
qreal y1 = std::sqrt(y1_sqr);
// Mirror x1, y1 along both the axes to get 4 points for the cross.
QPointF p1(xc + x1, yc + y1);
QPointF p2(xc - x1, yc + y1);
QPointF p3(xc + x1, yc - y1);
QPointF p4(xc - x1, yc - y1);
// Translate as we calculate for ellipse with (0, 0) as center.
p->translate(r.center().x(), r.center().y());
// Draw the cross now
p->drawLine(QLineF(p1, p4));
p->drawLine(QLineF(p2, p3));
// Restore the translate on painter.
p->translate(-r.center().x(), -r.center().y());
}
void QgsComposerPicture::setPictureRotation( double r )
{
double oldRotation = mPictureRotation;
mPictureRotation = r;
if ( mResizeMode == Zoom )
{
//find largest scaling of picture with this rotation which fits in item
QSizeF currentPictureSize = pictureSize();
QRectF rotatedImageRect = QgsComposerUtils::largestRotatedRectWithinBounds( QRectF( 0, 0, currentPictureSize.width(), currentPictureSize.height() ), rect(), mPictureRotation );
mPictureWidth = rotatedImageRect.width();
mPictureHeight = rotatedImageRect.height();
update();
}
else if ( mResizeMode == ZoomResizeFrame )
{
QSizeF currentPictureSize = pictureSize();
QRectF oldRect = QRectF( pos().x(), pos().y(), rect().width(), rect().height() );
//calculate actual size of image inside frame
QRectF rotatedImageRect = QgsComposerUtils::largestRotatedRectWithinBounds( QRectF( 0, 0, currentPictureSize.width(), currentPictureSize.height() ), rect(), oldRotation );
//rotate image rect by new rotation and get bounding box
QTransform tr;
tr.rotate( mPictureRotation );
QRectF newRect = tr.mapRect( QRectF( 0, 0, rotatedImageRect.width(), rotatedImageRect.height() ) );
//keep the center in the same location
newRect.moveCenter( oldRect.center() );
QgsComposerItem::setSceneRect( newRect );
emit itemChanged();
}
emit pictureRotationChanged( mPictureRotation );
}
void SkDrawCommandGeometryWidget::paintEvent(QPaintEvent* event) {
this->QFrame::paintEvent(event);
if (!fSurface) {
return;
}
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing);
SkImageInfo info;
size_t rowBytes;
if (const void* pixels = fSurface->peekPixels(&info, &rowBytes)) {
SkASSERT(info.width() > 0);
SkASSERT(info.height() > 0);
QRectF resultRect;
if (this->width() < this->height()) {
float ratio = this->width() / info.width();
resultRect = QRectF(0, 0, this->width(), ratio * info.height());
} else {
float ratio = this->height() / info.height();
resultRect = QRectF(0, 0, ratio * info.width(), this->height());
}
resultRect.moveCenter(this->contentsRect().center());
QImage image(reinterpret_cast<const uchar*>(pixels),
info.width(),
info.height(),
rowBytes,
QImage::Format_ARGB32_Premultiplied);
painter.drawImage(resultRect, image);
}
}
/*!
\brief Paint event
Repaint the grabbed pixmap on its current position and
fill the empty spaces by the background of the parent widget.
\param event Paint event
*/
void QwtPanner::paintEvent( QPaintEvent *event )
{
int dx = d_data->pos.x() - d_data->initialPos.x();
int dy = d_data->pos.y() - d_data->initialPos.y();
QRectF r;
r.setSize( d_data->pixmap.size() / QwtPainter::devicePixelRatio( &d_data->pixmap ) );
r.moveCenter( QPointF( r.center().x() + dx, r.center().y() + dy ) );
QPixmap pm = QwtPainter::backingStore( this, size() );
QwtPainter::fillPixmap( parentWidget(), pm );
QPainter painter( &pm );
if ( !d_data->contentsMask.isNull() )
{
QPixmap masked = d_data->pixmap;
masked.setMask( d_data->contentsMask );
painter.drawPixmap( r.toRect(), masked );
}
else
{
painter.drawPixmap( r.toRect(), d_data->pixmap );
}
painter.end();
if ( !d_data->contentsMask.isNull() )
pm.setMask( d_data->contentsMask );
painter.begin( this );
painter.setClipRegion( event->region() );
painter.drawPixmap( 0, 0, pm );
}
/*!
Expand the selected rectangle to minZoomSize() and zoom in
if accepted.
\sa accept(), minZoomSize()
*/
bool QwtPlotZoomer::end( bool ok )
{
ok = QwtPlotPicker::end( ok );
if ( !ok )
return false;
QwtPlot *plot = QwtPlotZoomer::plot();
if ( !plot )
return false;
const QPolygon &pa = selection();
if ( pa.count() < 2 )
return false;
QRect rect = QRect( pa[0], pa[int( pa.count() - 1 )] );
rect = rect.normalized();
QRectF zoomRect = invTransform( rect ).normalized();
const QSizeF minSize = minZoomSize();
if ( minSize.isValid() )
{
const QPointF center = zoomRect.center();
zoomRect.setSize( zoomRect.size().expandedTo( minZoomSize() ) );
zoomRect.moveCenter( center );
}
zoom( zoomRect );
return true;
}
void FormulaView::renderFormula( QPainter *painter ) const
{
QwtMathMLDocument doc;
doc.setContent( d_formula );
doc.setBaseFontPointSize( d_fontSize );
QRectF docRect;
docRect.setSize( doc.size() );
docRect.moveCenter( rect().center() );
if ( d_transformation )
{
const double scaleF = d_scale ? 2.0 : 1.0;
painter->save();
painter->translate( docRect.center() );
painter->rotate( d_rotation );
painter->scale( scaleF, scaleF );
painter->translate( docRect.topLeft() - docRect.center() );
doc.paint( painter, QPointF( 0, 0 ) );
painter->restore();
}
else
{
doc.paint( painter, docRect.topLeft().toPoint() );
}
}
void GraphicsBoard::setHighlights(const QList<Chess::Square>& squares)
{
clearHighlights();
if (squares.isEmpty())
return;
TargetHighlights* targets = new TargetHighlights(this);
QRectF rect;
rect.setSize(QSizeF(m_squareSize / 3, m_squareSize / 3));
rect.moveCenter(QPointF(0, 0));
QPen pen(Qt::white, m_squareSize / 20);
QBrush brush(Qt::black);
for (const auto& sq : squares)
{
QGraphicsEllipseItem* dot = new QGraphicsEllipseItem(rect, targets);
dot->setCacheMode(DeviceCoordinateCache);
dot->setPen(pen);
dot->setBrush(brush);
dot->setPos(squarePos(sq));
}
m_highlightAnim = new QPropertyAnimation(targets, "opacity");
targets->setParent(m_highlightAnim);
m_highlightAnim->setStartValue(0.0);
m_highlightAnim->setEndValue(1.0);
m_highlightAnim->setDuration(500);
m_highlightAnim->setEasingCurve(QEasingCurve::InOutQuad);
m_highlightAnim->start(QAbstractAnimation::KeepWhenStopped);
}
void LensDialog::setNewLensX(double x)
{
QRectF r = lensList[currentLens]->rect();
r.moveCenter(QPointF(x, r.center().y()));
lensList[currentLens]->setRect(r);
lensList[currentLens]->updateEffect();
}
bool DrawingTouch::update(QBrush *color)
{
bool wasVisible = false;
if (ellipse) {
wasVisible = ellipse->isVisible();
ellipse->setVisible(TrackingId() >= 0);
}
else {
ellipse = scene->addEllipse(QRectF(Cx() - radius, Cy() - radius,
2 * radius, 2 * radius));
}
if (TrackingId() >= 0) {
QRectF rect = ellipse->rect();
rect.moveCenter(QPointF(Cx(), Cy()));
ellipse->setRect(rect);
ellipse->setPen(Pressed() ? pressedPen : releasedPen);
if (!wasVisible) {
ellipse->setBrush(*color);
ellipse->show();
return true;
}
}
return false;
}
void LensDialog::setNewLensY(double y)
{
QRectF r = lensList[currentLens]->rect();
r.moveCenter(QPointF(r.center().x(), y));
lensList[currentLens]->setRect(r);
lensList[currentLens]->updateEffect();
}
void TeachableCirlce::positionChanged(QGraphicsEllipseItem *item, const QPointF &position)
{
QRectF rect = m_ellipseItem->rect();
if (item == m_center)
{
QPointF delta = position - rect.center();
m_teachedPointOnCircle += delta;
rect.moveCenter(position);
}
else if (item == m_pointOnCircle)
{
m_teachedPointOnCircle = position;
QPointF center = rect.center();
QPointF delta = position - center;
double r = sqrt(delta.x() * delta.x() + delta.y() * delta.y());
QPointF p1(center.x() - r, center.y() - r);
QPointF p2(center.x() + r, center.y() + r);
rect = QRectF(p1, p2);
}
m_ellipseItem->setRect(rect);
}
bool PlotZoomer::end(bool ok)
{
// Code here is taken from QwtPlotZoomer. The only modification is around the _zoomMode handling.
ok = QwtPlotPicker::end(ok);
if (!ok)
{
return false;
}
QwtPlot *plot = QwtPlotZoomer::plot();
if (!plot)
{
return false;
}
const QPolygon &pa = selection();
if (pa.count() < 2)
{
return false;
}
QRect rect = QRect(pa[0], pa[int(pa.count() - 1)]);
rect = rect.normalized();
QRectF currentZoomRect = zoomRect();
QRectF zoomRect = invTransform(rect).normalized();
switch (_zoomMode)
{
default:
case ZoomBoth:
// nothing.
break;
case ZoomX:
// Maintain current zoom y and height.
zoomRect.setY(currentZoomRect.y());
zoomRect.setHeight(currentZoomRect.height());
break;
case ZoomY:
// Maintain current zoom x and width.
zoomRect.setX(currentZoomRect.x());
zoomRect.setWidth(currentZoomRect.width());
break;
}
const QSizeF minSize = minZoomSize();
if (minSize.isValid())
{
const QPointF center = zoomRect.center();
zoomRect.setSize(zoomRect.size().expandedTo(minZoomSize()));
zoomRect.moveCenter(center);
}
zoom(zoomRect);
return true;
}
void EllipseObject::setObjectSize(qreal width, qreal height)
{
QRectF elRect = rect();
elRect.setWidth(width);
elRect.setHeight(height);
elRect.moveCenter(QPointF(0,0));
setRect(elRect);
}
void CircleObject::setObjectDiameter(qreal diameter)
{
QRectF circRect;
circRect.setWidth(diameter);
circRect.setHeight(diameter);
circRect.moveCenter(QPointF(0,0));
setRect(circRect);
}
QRectF Annotation::boundingRect() const
{
QFontMetricsF metrics(font);
QRectF rect = metrics.boundingRect(str);
rect.moveCenter(QPointF(0, y));
rect.adjust(-4, 0, +4, 0);
return rect;
}
QRectF KoToolBase::handlePaintRect(const QPointF &position) const
{
Q_D(const KoToolBase);
const KoViewConverter * converter = d->canvas->viewConverter();
uint handleSize = 2*handleRadius();
QRectF r = converter->viewToDocument(QRectF(0, 0, handleSize, handleSize));
r.moveCenter(position);
return r;
}
QPainterPath LineItem::rightMidGrip() const {
QRectF bound = gripBoundingRect();
QRectF grip = QRectF(bound.topRight() - QPointF(sizeOfGrip().width(), 0), sizeOfGrip());
grip.moveCenter(QPointF(grip.center().x(), bound.center().y()));
QPainterPath path;
path.addEllipse(grip);
return path;
}
void ConnectionTool::paint(QPainter &painter, const KoViewConverter &converter)
{
// get the correctly sized rect for painting handles
QRectF handleRect = handlePaintRect(QPointF());
painter.setRenderHint(QPainter::Antialiasing, true);
if (m_currentStrategy) {
painter.save();
m_currentStrategy->paint(painter, converter);
painter.restore();
}
QList<KoShape*> shapes = canvas()->shapeManager()->shapes();
for (QList<KoShape*>::const_iterator end = shapes.constBegin(); end != shapes.constEnd(); ++end) {
KoShape* shape = *end;
if (!dynamic_cast<KoConnectionShape*>(shape)) {
// only paint connection points of textShapes not inside a tos container and other shapes
if (shape->shapeId() == TextShape_SHAPEID && dynamic_cast<KoTosContainer*>(shape->parent())) continue;
painter.save();
painter.setPen(Qt::black);
QTransform transform = shape->absoluteTransformation(0);
KoShape::applyConversion(painter, converter);
// Draw all the connection points of the shape
KoConnectionPoints connectionPoints = shape->connectionPoints();
KoConnectionPoints::const_iterator cp = connectionPoints.constBegin();
KoConnectionPoints::const_iterator lastCp = connectionPoints.constEnd();
for(; cp != lastCp; ++cp) {
if (shape == findNonConnectionShapeAtPosition(transform.map(cp.value().position)) ) {
handleRect.moveCenter(transform.map(cp.value().position));
painter.setBrush(cp.key() == m_activeHandle && shape == m_currentShape ?
Qt::red : Qt::white);
painter.drawRect(handleRect);
}
}
painter.restore();
}
}
// paint connection points or connection handles depending
// on the shape the mouse is currently
if (m_currentShape && m_editMode == EditConnection) {
KoConnectionShape *connectionShape = dynamic_cast<KoConnectionShape*>(m_currentShape);
if (connectionShape) {
int radius = handleRadius()+1;
int handleCount = connectionShape->handleCount();
for(int i = 0; i < handleCount; ++i) {
painter.save();
painter.setPen(Qt::blue);
painter.setBrush(i == m_activeHandle ? Qt::red : Qt::white);
painter.setTransform(connectionShape->absoluteTransformation(&converter) * painter.transform());
connectionShape->paintHandle(painter, converter, i, radius);
painter.restore();
}
}
}
}
void Bubble::updateLine()
{
QRectF r = _rectangle->rect(); r.moveCenter(_rectangle->pos());
QPointF p((r.center().x() < 0.0 ? 0.5:-0.5) * r.width(),
(r.center().y() < 0.0 ? 0.5:-0.5) * r.height());
_line->setLine(QLineF(QPointF(0, 0), _rectangle->pos() + p));
_line->setVisible(!r.contains(0, 0));
}
void ExploreLiveView::postPaint(QPainter *painter)
{
QColor penColor = Qt::white;
penColor.setAlphaF(0.25);
painter->setPen(QPen(penColor, 3));
QRectF circle = shapeRect;
circle.moveCenter(QPointF(0, 0));
painter->drawEllipse(circle);
}
void EllipseObject::setObjectDiameterMinor(qreal diameter)
{
QRectF elRect = rect();
if(elRect.width() < elRect.height())
elRect.setWidth(diameter);
else
elRect.setHeight(diameter);
elRect.moveCenter(QPointF(0,0));
setRect(elRect);
}
QRectF Link::labelBoundingRect() const {
QPointF centre = ((m_from->pos() + m_from->boundingRect().center())
+ (m_to->pos() + m_to->boundingRect().center())) / 2.0;
QFontMetricsF fm((QFont()));
QRectF tbr = fm.boundingRect(m_label);
if(m_label == "") tbr.setSize(QSizeF(10,10));
tbr.moveCenter(centre);
return tbr;
}
void DashboardWindowContainer::mousePressEvent(QGraphicsSceneMouseEvent* event)
{
m_anim.stop();
m_anim.clear();
m_trackingMouseDirection = true;
m_vertLockedMovement = true;
m_seenFlick = false;
m_dashboardManualDrag = false;
event->accept();
m_draggedWindow.clear();
DashboardWindow* w;
Q_FOREACH(w, m_items) {
if (m_pendingDeleteItems.contains(w))
continue;
QRectF r = w->boundingRect();
r.moveCenter(w->pos());
if (r.contains(event->pos())) {
m_draggedWindow = w;
// check if this is a grouped notification window
if(w->isManualDragWindow()) {
if(w->x() == (m_isMenu ? w->boundingRect().width()/2 : 0)) { // check if the window is at its 'resting' position
int winX = event->pos().x() + (m_isMenu ? 0 : w->boundingRect().width()/2);
int winY = event->pos().y() - w->pos().y() + w->boundingRect().height()/2;
if(winX > sDashboardBadgeWidth) {
m_dashboardManualDrag = true;
// send the mouse down to the web app side
Event ev;
ev.type = Event::PenDown;
ev.setMainFinger(true);
ev.x = winX;
ev.y = winY;
ev.clickCount = 1;
ev.modifiers = Event::modifiersFromQt(event->modifiers());
ev.time = Time::curSysTimeMs();
w->inputEvent(&ev);
}
}
}
break;
}
}
// Don't drag a pending delete item
if (DashboardWindow* w = m_draggedWindow.data()) {
if (m_pendingDeleteItems.contains(w))
m_draggedWindow.clear();
}
}
QPainterPath CopyFilterGUIConnectionItem::shape() const
{
QLineF l = line();
QPainterPath path;
path.setFillRule(Qt::WindingFill);
double length = line().length();
if (length > 0)
{
double offset = min(length, maxArrowSize);
QLineF unit = l.unitVector();
QLineF normal = l.normalVector().unitVector();
QPointF v(unit.dx(), unit.dy());
QPointF n(normal.dx(), normal.dy());
QPointF p2 = l.p2();
QPointF p3 = p2 - v * offset + 0.5 * n * offset;
QPointF p4 = p2 - v * offset - 0.5 * n * offset;
QPolygonF polygon;
polygon.append(p4);
polygon.append(p3);
polygon.append(p2);
path.addPolygon(polygon);
QPolygonF polygon2;
QPointF p1 = l.p1();
polygon2.append(p2 + 3 * n);
polygon2.append(p2 - 2 * n);
polygon2.append(p1 - 2 * n);
polygon2.append(p1 + 3 * n);
path.addPolygon(polygon2);
if (factor != 1.0 || isDecibel)
{
QFont font;
font.setPixelSize(10);
QPointF center = (l.p1() + l.p2()) / 2;
QString text = QString("%1").arg(factor);
if (isDecibel)
text += " dB";
QFontMetrics fontMetrics(font);
QSizeF size = fontMetrics.size(0, text);
size += QSizeF(2, 0);
QRectF rect;
rect.setSize(size);
rect.moveCenter(center);
path.addRoundedRect(rect.adjusted(-0.5, 0.5, 0.5, 0.5), 3, 3);
}
}
return path;
}
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 CopyFilterGUIConnectionItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
{
QLineF l = line();
if (!l.isNull())
{
painter->setBrush(Qt::black);
if (isSelected())
{
painter->setBrush(Qt::blue);
painter->setPen(QPen(Qt::blue, 1.5));
}
painter->drawLine(line());
double length = line().length();
double offset = min(length, maxArrowSize);
QLineF unit = l.unitVector();
QLineF normal = l.normalVector().unitVector();
QPointF v(unit.dx(), unit.dy());
QPointF n(normal.dx(), normal.dy());
QPointF p2 = l.p2();
QPointF p3 = p2 - v * offset + 0.5 * n * offset;
QPointF p4 = p2 - v * offset - 0.5 * n * offset;
QPolygonF polygon;
polygon.append(p2);
polygon.append(p3);
polygon.append(p4);
painter->drawPolygon(polygon);
if (factor != 1.0 || isDecibel)
{
QFont font = painter->font();
font.setPixelSize(10);
painter->setFont(font);
QPointF center = (l.p1() + l.p2()) / 2;
QString text = QString("%1").arg(factor);
if (isDecibel)
text += " dB";
QSizeF size = painter->fontMetrics().size(0, text);
size += QSizeF(2, 0);
QRectF rect;
rect.setSize(size);
rect.moveCenter(center);
painter->setBrush(Qt::white);
painter->drawRoundedRect(rect.adjusted(-0.5, 0.5, 0.5, 0.5), 3, 3);
painter->drawText(rect, Qt::AlignCenter, text);
}
}
}
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]);
}
QFontMetricsF fm(p->font());
// If the height is too small increase the Height of the button to shall the whole text #192988
if (elementRect.height() < fm.height()) {
QPointF oldCenter = elementRect.center();
elementRect.setHeight(fm.height());
elementRect.moveCenter(oldCenter);
}
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();
}
}
}
