/*! Store a path command in the command list \sa QPaintEngine::drawPath() */ void QwtGraphic::drawPath( const QPainterPath &path ) { const QPainter *painter = paintEngine()->painter(); if ( painter == NULL ) return; d_data->commands += QwtPainterCommand( path ); if ( !path.isEmpty() ) { const QPainterPath scaledPath = painter->transform().map( path ); QRectF pointRect = scaledPath.boundingRect(); QRectF boundingRect = pointRect; if ( painter->pen().style() != Qt::NoPen && painter->pen().brush().style() != Qt::NoBrush ) { boundingRect = qwtStrokedPathRect( painter, path ); } updateControlPointRect( pointRect ); updateBoundingRect( boundingRect ); d_data->pathInfos += PathInfo( pointRect, boundingRect, qwtHasScalablePen( painter ) ); } }
/*! \overload Creates and returns a QPainterPath object that is a copy of the given \a path, mapped into the coordinate system defined by this matrix. */ QPainterPath QMatrix::map(const QPainterPath &path) const { if (path.isEmpty()) return QPainterPath(); QPainterPath copy = path; // Translate or identity if (_m11 == 1.0 && _m22 == 1.0 && _m12 == 0.0 && _m21 == 0.0) { // Translate if (_dx != 0.0 || _dy != 0.0) { copy.detach(); for (int i=0; i<path.elementCount(); ++i) { QPainterPath::Element &e = copy.d_ptr->elements[i]; e.x += _dx; e.y += _dy; } } // Full xform } else { copy.detach(); for (int i=0; i<path.elementCount(); ++i) { QPainterPath::Element &e = copy.d_ptr->elements[i]; qreal fx = e.x, fy = e.y; e.x = _m11*fx + _m21*fy + _dx; e.y = _m12*fx + _m22*fy + _dy; } } return copy; }
void CSharedPainterScene::drawLastItemBorderRect( void ) { if( ! lastAddItem_ ) return; if( ! lastAddItem_->drawingObject() ) return; QAbstractGraphicsShapeItem* i = reinterpret_cast<QAbstractGraphicsShapeItem *>(lastAddItem_->drawingObject()); if( ! i ) return; // setting style.. QPainterPath path = createCoveringBorderPath( lastItemBorderType_, i ); if ( path.isEmpty() ) return; clearLastItemBorderRect(); QAbstractGraphicsShapeItem* lastBorderItem = addPath( path ); lastBorderItem->setPen( QPen( Util::getComplementaryColor(backgroundColor_, penColor() ), 2) ); lastBorderItem->setZValue( currentZValue() ); lastCoverGraphicsItem_ = lastBorderItem; // clear lastTempBlinkShowFlag_ = true; lastTimeValue_ = QDateTime::currentDateTime().toMSecsSinceEpoch(); timeoutRemoveLastCoverItem_ = DEFAULT_TIMEOUT_REMOVE_LAST_COVER_ITEM; }
void QPaintEngineEx::drawStaticTextItem(QStaticTextItem *staticTextItem) { QPainterPath path; #ifndef Q_WS_MAC path.setFillRule(Qt::WindingFill); #endif if (staticTextItem->numGlyphs == 0) return; QFontEngine *fontEngine = staticTextItem->fontEngine(); fontEngine->addGlyphsToPath(staticTextItem->glyphs, staticTextItem->glyphPositions, staticTextItem->numGlyphs, &path, 0); if (!path.isEmpty()) { QPainterState *s = state(); QPainter::RenderHints oldHints = s->renderHints; bool changedHints = false; if (bool(oldHints & QPainter::TextAntialiasing) && !bool(fontEngine->fontDef.styleStrategy & QFont::NoAntialias) && !bool(oldHints & QPainter::Antialiasing)) { s->renderHints |= QPainter::Antialiasing; renderHintsChanged(); changedHints = true; } fill(qtVectorPathForPath(path), s->pen.color()); if (changedHints) { s->renderHints = oldHints; renderHintsChanged(); } } }
void QgsCircularString::addToPainterPath( QPainterPath &path ) const { int nPoints = numPoints(); if ( nPoints < 1 ) { return; } if ( path.isEmpty() || path.currentPosition() != QPointF( mX[0], mY[0] ) ) { path.moveTo( QPointF( mX[0], mY[0] ) ); } for ( int i = 0; i < ( nPoints - 2 ) ; i += 2 ) { QgsPointSequence pt; segmentize( QgsPointV2( mX[i], mY[i] ), QgsPointV2( mX[i + 1], mY[i + 1] ), QgsPointV2( mX[i + 2], mY[i + 2] ), pt ); for ( int j = 1; j < pt.size(); ++j ) { path.lineTo( pt.at( j ).x(), pt.at( j ).y() ); } //arcTo( path, QPointF( mX[i], mY[i] ), QPointF( mX[i + 1], mY[i + 1] ), QPointF( mX[i + 2], mY[i + 2] ) ); } //if number of points is even, connect to last point with straight line (even though the circular string is not valid) if ( nPoints % 2 == 0 ) { path.lineTo( mX[ nPoints - 1 ], mY[ nPoints - 1 ] ); } }
void TestSnapStrategy::testOrhogonalDecoration() { //Making sure the decoration is created but is empty OrthogonalSnapStrategy toTestTwo; const QPointF paramMousePositionTwo(3,3); MockShapeController fakeShapeControllerBaseTwo; MockCanvas fakeKoCanvasBaseTwo(&fakeShapeControllerBaseTwo); KoShapeManager *fakeShapeManager = fakeKoCanvasBaseTwo.shapeManager(); MockShape fakeShapeOne; QList<QPointF> firstSnapPointList; firstSnapPointList.push_back(QPointF(1,2)); firstSnapPointList.push_back(QPointF(2,2)); firstSnapPointList.push_back(QPointF(3,2)); firstSnapPointList.push_back(QPointF(4,2)); fakeShapeOne.snapData().setSnapPoints(firstSnapPointList); fakeShapeOne.isVisible(true); fakeShapeManager->addShape(&fakeShapeOne); KoSnapGuide aKoSnapGuideTwo(&fakeKoCanvasBaseTwo); KoSnapProxy paramProxyTwo(&aKoSnapGuideTwo); //Make sure at least one point in firstSnapPointList is within this distance of //paramMousePoint to trigger the branches if (dx < minHorzDist && dx < maxSnapDistance) //and if (dy < minVertDist && dy < maxSnapDistance) WHICH IS WHERE minVertDist and minHorzDist //ARE CHANGED FROM HUGE_VAL qreal paramSnapDistanceTwo = 4; toTestTwo.snap(paramMousePositionTwo, ¶mProxyTwo, paramSnapDistanceTwo); KoViewConverter irrelevantParameter; QPainterPath resultingDecoration = toTestTwo.decoration(irrelevantParameter); QVERIFY( resultingDecoration.isEmpty() ); }
int QTextureGlyphCache::calculateSubPixelPositionCount(glyph_t glyph) const { // Test 12 different subpixel positions since it factors into 3*4 so it gives // the coverage we need. QList<QImage> images; for (int i=0; i<12; ++i) { QImage img = textureMapForGlyph(glyph, QFixed::fromReal(i / 12.0)); if (images.isEmpty()) { QPainterPath path; QFixedPoint point; m_current_fontengine->addGlyphsToPath(&glyph, &point, 1, &path, QTextItem::RenderFlags()); // Glyph is space, return 0 to indicate that we need to keep trying if (path.isEmpty()) break; images.append(img); } else { bool found = false; for (int j=0; j<images.size(); ++j) { if (images.at(j) == img) { found = true; break; } } if (!found) images.append(img); } } return images.size(); }
void QPaintEngineEx::clip(const QPainterPath &path, Qt::ClipOperation op) { if (path.isEmpty()) { QVectorPath vp(0, 0); clip(vp, op); } else { clip(qtVectorPathForPath(path), op); } }
void QOutlineMapper::clipElements(const QPointF *elements, const QPainterPath::ElementType *types, int element_count) { // We could save a bit of time by actually implementing them fully // instead of going through convenience functionallity, but since // this part of code hardly every used, it shouldn't matter. m_in_clip_elements = true; QPainterPath path; if (!(m_outline.flags & QT_FT_OUTLINE_EVEN_ODD_FILL)) path.setFillRule(Qt::WindingFill); if (types) { for (int i=0; i<element_count; ++i) { switch (types[i]) { case QPainterPath::MoveToElement: path.moveTo(elements[i]); break; case QPainterPath::LineToElement: path.lineTo(elements[i]); break; case QPainterPath::CurveToElement: path.cubicTo(elements[i], elements[i+1], elements[i+2]); i += 2; break; default: break; } } } else { path.moveTo(elements[0]); for (int i=1; i<element_count; ++i) path.lineTo(elements[i]); } QPainterPath clipPath; clipPath.addRect(m_clip_rect); QPainterPath clippedPath = path.intersected(clipPath); uint old_txop = m_txop; m_txop = QTransform::TxNone; if (clippedPath.isEmpty()) m_valid = false; else convertPath(clippedPath); m_txop = old_txop; m_in_clip_elements = false; }
QString QTikzPicturePrivate::toTikzPath(const QPainterPath & path) const { if (path.isEmpty()) return QString(); QStringList pathList; QString currentPath; int currentControlPoint = 0; // convert QPainterPath to a TikZ path string for (int i = 0; i < path.elementCount(); i++) { const QPainterPath::Element & element = path.elementAt(i); switch (element.type) { case QPainterPath::MoveToElement: { // close current path + append to path list if (!currentPath.isEmpty()) { currentPath += " -- cycle"; pathList << currentPath; } // indent with spaces for better readability const char * indentString = pathList.count() ? " " : ""; // start new path currentPath.clear(); currentPath += indentString + toCoord(element); break; } case QPainterPath::LineToElement: { currentPath += " -- " + toCoord(element); break; } case QPainterPath::CurveToElement: { currentPath += " .. controls " + toCoord(element); currentControlPoint = 1; break; } case QPainterPath::CurveToDataElement: { if (currentControlPoint == 1) { currentPath += " and " + toCoord(element); ++currentControlPoint; } else if (currentControlPoint == 2) { currentPath += " .. " + toCoord(element); currentControlPoint = 0; } break; } } } return pathList.join("\n"); }
void GraphicsUtils::qt_graphicsItem_highlightSelected(QPainter *painter, const QStyleOptionGraphicsItem *option, const QRectF & boundingRect, const QPainterPath & path) { const QRectF murect = painter->transform().mapRect(QRectF(0, 0, 1, 1)); if (qFuzzyCompare(qMax(murect.width(), murect.height()) + 1, 1)) return; const QRectF mbrect = painter->transform().mapRect(boundingRect); if (qMin(mbrect.width(), mbrect.height()) < double(1.0)) return; double itemPenWidth = 1.0; const double pad = itemPenWidth / 2; const double penWidth = 0; // cosmetic pen const QColor fgcolor = option->palette.windowText().color(); const QColor bgcolor( // ensure good contrast against fgcolor fgcolor.red() > 127 ? 0 : 255, fgcolor.green() > 127 ? 0 : 255, fgcolor.blue() > 127 ? 0 : 255); painter->setPen(QPen(bgcolor, penWidth, Qt::SolidLine)); painter->setBrush(Qt::NoBrush); if (path.isEmpty()) { painter->drawRect(boundingRect.adjusted(pad, pad, -pad, -pad)); } else { painter->drawPath(path); } painter->setPen(QPen(option->palette.windowText(), 0, Qt::DashLine)); painter->setBrush(Qt::NoBrush); if (path.isEmpty()) { painter->drawRect(boundingRect.adjusted(pad, pad, -pad, -pad)); } else { painter->drawPath(path); } }
QPainterPath AbstractArrow::contour(qreal width) const { QPainterPath arrowPath = path(); // if path is empty, return immediately if (arrowPath.isEmpty()) { return QPainterPath(); } QPainterPathStroker stroker; stroker.setJoinStyle(Qt::RoundJoin); stroker.setCapStyle(Qt::RoundCap); stroker.setWidth(width + style()->penWidth().toPoint()); return stroker.createStroke(arrowPath); }
/*! \brief Set the shape to be displayed \param shape Shape \sa setShape(), shape() */ void QwtPlotShapeItem::setShape( const QPainterPath &shape ) { if ( shape != d_data->shape ) { d_data->shape = shape; if ( shape.isEmpty() ) { d_data->boundingRect = QwtPlotItem::boundingRect(); } else { d_data->boundingRect = shape.boundingRect(); } itemChanged(); } }
/*! Calculate a mask, that can be used to clip away the border frame \param size Size including the frame */ QBitmap QwtPlotCanvas::borderMask( const QSize &size ) const { const QRect r( 0, 0, size.width(), size.height() ); const QPainterPath path = borderPath( r ); if ( path.isEmpty() ) return QBitmap(); QImage image( size, QImage::Format_ARGB32_Premultiplied ); image.fill( Qt::color0 ); QPainter painter( &image ); painter.setClipPath( path ); painter.fillRect( r, Qt::color1 ); // now erase the frame painter.setCompositionMode( QPainter::CompositionMode_DestinationOut ); if ( testAttribute(Qt::WA_StyledBackground ) ) { QStyleOptionFrame opt; opt.initFrom(this); opt.rect = r; style()->drawPrimitive( QStyle::PE_Frame, &opt, &painter, this ); } else { if ( d_data->borderRadius > 0 && frameWidth() > 0 ) { painter.setPen( QPen( Qt::color1, frameWidth() ) ); painter.setBrush( Qt::NoBrush ); painter.setRenderHint( QPainter::Antialiasing, true ); painter.drawPath( path ); } } painter.end(); const QImage mask = image.createMaskFromColor( QColor( Qt::color1 ).rgb(), Qt::MaskOutColor ); return QBitmap::fromImage( mask ); }
void QPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem) { const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem); QPainterPath path; path.setFillRule(Qt::WindingFill); if (ti.glyphs.numGlyphs) ti.fontEngine->addOutlineToPath(0, 0, ti.glyphs, &path, ti.flags); if (!path.isEmpty()) { painter()->save(); painter()->setRenderHint(QPainter::Antialiasing, bool((painter()->renderHints() & QPainter::TextAntialiasing) && !(painter()->font().styleStrategy() & QFont::NoAntialias))); painter()->translate(p.x(), p.y()); painter()->fillPath(path, state->pen().brush()); painter()->restore(); } }
void QgsLineStringV2::addToPainterPath( QPainterPath& path ) const { int nPoints = numPoints(); if ( nPoints < 1 ) { return; } if ( path.isEmpty() || path.currentPosition() != QPointF( mX.at( 0 ), mY.at( 0 ) ) ) { path.moveTo( mX.at( 0 ), mY.at( 0 ) ); } for ( int i = 1; i < nPoints; ++i ) { path.lineTo( mX.at( i ), mY.at( i ) ); } }
void QgsLineStringV2::addToPainterPath( QPainterPath& path ) const { int nPoints = numPoints(); if ( nPoints < 1 ) { return; } if ( path.isEmpty() || path.currentPosition() != mCoords[0] ) { path.moveTo( mCoords[0] ); } for ( int i = 1; i < nPoints; ++i ) { path.lineTo( mCoords[i] ); } }
/*! Draws the first \a rectCount rectangles in the buffer \a rects. The default implementation of this function calls drawPath() or drawPolygon() depending on the feature set of the paint engine. */ void QPaintEngine::drawRects(const QRectF *rects, int rectCount) { if (hasFeature(PainterPaths) && !state->penNeedsResolving() && !state->brushNeedsResolving()) { for (int i=0; i<rectCount; ++i) { QPainterPath path; path.addRect(rects[i]); if (path.isEmpty()) continue; drawPath(path); } } else { for (int i=0; i<rectCount; ++i) { QRectF rf = rects[i]; QPointF pts[4] = { QPointF(rf.x(), rf.y()), QPointF(rf.x() + rf.width(), rf.y()), QPointF(rf.x() + rf.width(), rf.y() + rf.height()), QPointF(rf.x(), rf.y() + rf.height()) }; drawPolygon(pts, 4, ConvexMode); } } }
void QwtWidgetOverlay::draw( QPainter *painter ) const { if ( QWidget *widget = parentWidget() ) { painter->setClipRect( widget->contentsRect() ); // something special for the plot canvas const int idx = widget->metaObject()->indexOfMethod( "borderPath(QRect)" ); if ( idx >= 0 ) { QPainterPath clipPath; ( void )QMetaObject::invokeMethod( widget, "borderPath", Qt::DirectConnection, Q_RETURN_ARG( QPainterPath, clipPath ), Q_ARG( QRect, rect() ) ); if (!clipPath.isEmpty()) painter->setClipPath( clipPath, Qt::IntersectClip ); } } drawOverlay( painter ); }
void QPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem) { const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem); if (ti.glyphs.numGlyphs == 0) return; if (ti.fontEngine->glyphFormat == QFontEngine::Format_ARGB) { QVarLengthArray<QFixedPoint> positions; QVarLengthArray<glyph_t> glyphs; QTransform matrix = QTransform::fromTranslate(p.x(), p.y() - ti.fontEngine->ascent().toReal()); ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions); painter()->save(); painter()->setRenderHint(QPainter::SmoothPixmapTransform, bool((painter()->renderHints() & QPainter::TextAntialiasing) && !(painter()->font().styleStrategy() & QFont::NoAntialias))); for (int i = 0; i < ti.glyphs.numGlyphs; ++i) { QImage glyph = ti.fontEngine->bitmapForGlyph(glyphs[i], QFixed(), QTransform()); painter()->drawImage(positions[i].x.toReal(), positions[i].y.toReal(), glyph); } painter()->restore(); return; } QPainterPath path; path.setFillRule(Qt::WindingFill); ti.fontEngine->addOutlineToPath(0, 0, ti.glyphs, &path, ti.flags); if (!path.isEmpty()) { painter()->save(); painter()->setRenderHint(QPainter::Antialiasing, bool((painter()->renderHints() & QPainter::TextAntialiasing) && !(painter()->font().styleStrategy() & QFont::NoAntialias))); painter()->translate(p.x(), p.y()); painter()->fillPath(path, painter()->pen().brush()); painter()->restore(); } }
void TemporalConstraintView::paint( QPainter* painter, const QStyleOptionGraphicsItem*, QWidget*) { auto& skin = ScenarioStyle::instance(); qreal min_w = minWidth(); qreal max_w = maxWidth(); qreal def_w = defaultWidth(); qreal play_w = playWidth(); m_labelItem->setPos(def_w / 2. - m_labelItem->boundingRect().width() / 2., -17); m_counterItem->setPos(def_w - m_counterItem->boundingRect().width() - 5, 5); m_leftBrace->setX(min_w); m_rightBrace->setX(max_w); // Draw the stuff present if there is a rack *in the model* ? if(presenter().rack()) { // Background auto rect = boundingRect(); rect.adjust(0,4,0,-10); rect.setWidth(this->defaultWidth()); QColor bgColor = m_bgColor.getColor(); bgColor.setAlpha(m_hasFocus ? 84 : 76); painter->fillRect(rect, bgColor); // Fake timenode continuation auto color = skin.RackSideBorder.getColor(); QPen pen{color, 2, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin}; painter->setPen(pen); painter->drawLine(rect.topLeft(), rect.bottomLeft()); painter->drawLine(rect.topRight(), rect.bottomRight()); } QPainterPath solidPath, dashedPath, leftBrace, rightBrace; // Paths if(infinite()) { if(min_w != 0.) { solidPath.lineTo(min_w, 0); m_leftBrace->show(); } m_rightBrace->hide(); // TODO end state should be hidden dashedPath.moveTo(min_w, 0); dashedPath.lineTo(def_w, 0); } else if(min_w == max_w) // TODO rigid() { solidPath.lineTo(def_w, 0); m_leftBrace->hide(); m_rightBrace->hide(); } else { if(min_w != 0.) solidPath.lineTo(min_w, 0); dashedPath.moveTo(min_w, 0); dashedPath.lineTo(max_w, 0); m_leftBrace->show(); m_rightBrace->show(); } QPainterPath playedPath; if(play_w != 0.) { playedPath.lineTo(std::min(play_w, std::max(def_w, max_w)), 0); } // Colors QColor constraintColor; // TODO make a switch instead if(isSelected()) { constraintColor = skin.ConstraintSelected.getColor(); } else if(warning()) { constraintColor = skin.ConstraintWarning.getColor(); } else { constraintColor = skin.ConstraintBase.getColor(); } if(! isValid() || m_state == ConstraintExecutionState::Disabled) { constraintColor = skin.ConstraintInvalid.getColor(); } m_solidPen.setColor(constraintColor); m_dashPen.setColor(constraintColor); // Drawing painter->setPen(m_solidPen); if(!solidPath.isEmpty()) painter->drawPath(solidPath); painter->setPen(m_dashPen); if(!dashedPath.isEmpty()) painter->drawPath(dashedPath); leftBrace.closeSubpath(); rightBrace.closeSubpath(); QPen anotherPen(Qt::transparent, 4); painter->setPen(anotherPen); QColor blueish = m_solidPen.color().lighter(); blueish.setAlphaF(0.3); painter->setBrush(blueish); const QPen playedPen{ skin.ConstraintPlayFill.getColor(), 4, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin }; painter->setPen(playedPen); if(!playedPath.isEmpty()) painter->drawPath(playedPath); { auto& dur = presenter().model().duration; auto progress = dur.defaultDuration() * dur.playPercentage(); if(!progress.isZero()) { QString percent = progress.toString(); m_counterItem->setText(percent); } } #if defined(ISCORE_SCENARIO_DEBUG_RECTS) painter->setPen(Qt::darkRed); painter->setBrush(Qt::NoBrush); painter->drawRect(boundingRect()); #endif }
static void qwtDrawBackground( QPainter *painter, QwtPlotCanvas *canvas ) { painter->save(); const QPainterPath borderClip = canvas->borderPath( canvas->rect() ); if ( !borderClip.isEmpty() ) painter->setClipPath( borderClip, Qt::IntersectClip ); const QBrush &brush = canvas->palette().brush( canvas->backgroundRole() ); if ( brush.style() == Qt::TexturePattern ) { QPixmap pm( canvas->size() ); qwtFillPixmap( canvas, pm ); painter->drawPixmap( 0, 0, pm ); } else if ( brush.gradient() ) { QVector<QRect> rects; if ( brush.gradient()->coordinateMode() == QGradient::ObjectBoundingMode ) { rects += canvas->rect(); } else { rects = painter->clipRegion().rects(); } #if 1 bool useRaster = false; if ( painter->paintEngine()->type() == QPaintEngine::X11 ) { // Qt 4.7.1: gradients on X11 are broken ( subrects + // QGradient::StretchToDeviceMode ) and horrible slow. // As workaround we have to use the raster paintengine. // Even if the QImage -> QPixmap translation is slow // it is three times faster, than using X11 directly useRaster = true; } #endif if ( useRaster ) { QImage::Format format = QImage::Format_RGB32; const QGradientStops stops = brush.gradient()->stops(); for ( int i = 0; i < stops.size(); i++ ) { if ( stops[i].second.alpha() != 255 ) { // don't use Format_ARGB32_Premultiplied. It's // recommended by the Qt docs, but QPainter::drawImage() // is horrible slow on X11. format = QImage::Format_ARGB32; break; } } QImage image( canvas->size(), format ); QPainter p( &image ); p.setPen( Qt::NoPen ); p.setBrush( brush ); p.drawRects( rects ); p.end(); painter->drawImage( 0, 0, image ); } else { painter->setPen( Qt::NoPen ); painter->setBrush( brush ); painter->drawRects( rects ); } } else { painter->setPen( Qt::NoPen ); painter->setBrush( brush ); painter->drawRects( painter->clipRegion().rects() ); } painter->restore(); }
int Nightcharts::draw(QPainter *painter) { painter->setRenderHint(QPainter::Antialiasing); painter->setPen(Qt::NoPen); if (this->ctype == Nightcharts::Pie) { pW = 0; double pdegree = 0; //Options QLinearGradient gradient(cX+0.5*cW,cY,cX+0.5*cW,cY+cH*2.5); gradient.setColorAt(1,Qt::black); //Draw //pdegree = (360/100)*pieces[i].pPerc; if (shadows) { double sumangle = 0; for (int i = 0; i < pieces.size(); i++) { sumangle += 3.6 * pieces[i].pPerc; } painter->setBrush(Qt::darkGray); painter->drawPie(cX,cY+pW+5,cW,cH,palpha*16,sumangle*16); } QPen pen; pen.setWidth(2); for (int i = 0; i < pieces.size(); i++) { gradient.setColorAt(0, pieces[i].rgbColor); painter->setBrush(gradient); pen.setColor(pieces[i].rgbColor); painter->setPen(pen); pdegree = 3.6 * pieces[i].pPerc; painter->drawPie(cX, cY, cW, cH, palpha*16, pdegree*16); palpha += pdegree; } } else if (this->ctype == Nightcharts::Dpie) { pW = 50; double pdegree = 0; QPointF p; QLinearGradient gradient(cX - 0.5 * cW, cY + cH/2, cX + 1.5 * cW, cY + cH/2); gradient.setColorAt(0,Qt::black); gradient.setColorAt(1,Qt::white); QLinearGradient gradient_side(cX, cY + cH, cX + cW, cY + cH); gradient_side.setColorAt(0,Qt::black); double sumangle = 0; for (int i = 0; i < pieces.size(); i++) { sumangle += 3.6 * pieces[i].pPerc; } if (shadows) { painter->setBrush(Qt::darkGray); painter->drawPie(cX, cY + pW + 5, cW, cH, palpha * 16, sumangle * 16); } int q = GetQuater(palpha+sumangle); if (q ==2 || q==3) { QPointF p = GetPoint(palpha+sumangle); QPointF points[4] = { QPointF(p.x(), p.y()), QPointF(p.x(), p.y() + pW), QPointF(cX + cW/2, cY + cH/2 + pW), QPointF(cX + cW/2, cY + cH/2) }; gradient_side.setColorAt(1, pieces[pieces.size()-1].rgbColor); painter->setBrush(gradient_side); painter->drawPolygon(points, 4); } p = GetPoint(palpha); q = GetQuater(palpha); if (q ==1 || q==4) { QPointF points[4] = { QPointF(p.x(), p.y()), QPointF(p.x(), p.y() + pW), QPointF(cX + cW/2, cY + cH/2 + pW), QPointF(cX + cW/2, cY + cH/2) }; gradient_side.setColorAt(1, pieces[0].rgbColor); painter->setBrush(gradient_side); painter->drawPolygon(points, 4); } for (int i = 0;i < pieces.size(); i++) { gradient.setColorAt(0.5, pieces[i].rgbColor); painter->setBrush(gradient); pdegree = 3.6 * pieces[i].pPerc; painter->drawPie(cX, cY, cW, cH, palpha * 16, pdegree * 16); double a_ = Angle360(palpha); int q_ = GetQuater(palpha); palpha += pdegree; double a = Angle360(palpha); int q = GetQuater(palpha); QPainterPath path; p = GetPoint(palpha); if((q == 3 || q == 4) && (q_ == 3 || q_ == 4)) { // 1) if (a>a_) { QPointF p_old = GetPoint(palpha-pdegree); path.moveTo(p_old.x() - 1, p_old.y()); path.arcTo(cX, cY, cW, cH, palpha-pdegree, pdegree); path.lineTo(p.x(), p.y() + pW); path.arcTo(cX, cY + pW, cW, cH, palpha, -pdegree); } // 2) else { path.moveTo(cX, cY + cH/2); path.arcTo(cX, cY, cW, cH, 180, Angle360(palpha) - 180); path.lineTo(p.x(), p.y() + pW); path.arcTo(cX, cY + pW, cW, cH, Angle360(palpha), -Angle360(palpha) + 180); path.lineTo(cX, cY + cH/2); path.moveTo(p.x(), p.y()); path.arcTo(cX, cY, cW, cH, palpha-pdegree, 360 - Angle360(palpha - pdegree)); path.lineTo(cX + cW, cY + cH/2 + pW); path.arcTo(cX, cY + pW, cW, cH, 0, -360 + Angle360(palpha - pdegree)); } } // 3) else if((q == 3 || q == 4) && (q_ == 1 || q_ == 2) && a>a_ ) { path.moveTo(cX,cY+cH/2); path.arcTo(cX,cY,cW,cH,180,Angle360(palpha)-180); path.lineTo(p.x(),p.y()+pW); path.arcTo(cX,cY+pW,cW,cH,Angle360(palpha),-Angle360(palpha)+180); path.lineTo(cX,cY+cH/2); } // 4) else if((q == 1 || q == 2) && (q_ == 3 || q_ == 4) && a<a_) { p = GetPoint(palpha-pdegree); path.moveTo(p.x(),p.y()); path.arcTo(cX,cY,cW,cH,palpha-pdegree,360-Angle360(palpha-pdegree)); path.lineTo(cX+cW,cY+cH/2+pW); path.arcTo(cX,cY+pW,cW,cH,0,-360+Angle360(palpha-pdegree)); } // 5) else if((q ==1 || q==2) && (q_==1 || q_==2) && a<a_) { path.moveTo(cX,cY+cH/2); path.arcTo(cX,cY,cW,cH,180,180); path.lineTo(cX+cW,cY+cH/2+pW); path.arcTo(cX,cY+pW,cW,cH,0,-180); path.lineTo(cX,cY+cH/2); } if (!path.isEmpty()) { gradient_side.setColorAt(1,pieces[i].rgbColor); painter->setBrush(gradient_side); painter->drawPath(path); } } } else if (this->ctype==Nightcharts::Histogramm) { double pDist = 15; double pW = (cW-(pieces.size())*pDist)/pieces.size(); QLinearGradient gradient(cX + cW/2, cY, cX + cW/2, cY + cH); gradient.setColorAt(0,Qt::black); QPen pen; pen.setWidth(3); for (int i = 0;i < pieces.size(); i++) { if (shadows) { painter->setPen(Qt::NoPen); painter->setBrush(Qt::darkGray); painter->drawRect(cX+pDist+i*(pW + pDist)-pDist/2,cY+cH-1,pW,-cH/100*pieces[i].pPerc+pDist/2-5); } gradient.setColorAt(1,pieces[i].rgbColor); painter->setBrush(gradient); pen.setColor(pieces[i].rgbColor); painter->setPen(pen); painter->drawRect(cX+pDist+i*(pW + pDist),cY+cH,pW,-cH/100*pieces[i].pPerc-5); QString label = QString::number(pieces[i].pPerc)+"%"; painter->setPen(Qt::SolidLine); painter->drawText(cX+pDist+i*(pW + pDist)+pW/2-painter->fontMetrics().width(label)/2,cY+cH-cH/100*pieces[i].pPerc-painter->fontMetrics().height()/2,label); } painter->setPen(Qt::SolidLine); for (int i = 1; i < 10; i++) { painter->drawLine(cX - 3, cY + cH/10 * i, cX + 3, cY + cH/10 * i); //§Õ§Ö§Ý§Ö§ß§Ú§ñ §á§à §à§ã§Ú Y //painter->drawText(cX-20,cY+cH/10*i,QString::number((10-i)*10)+"%"); } painter->drawLine(cX,cY+cH,cX,cY); //§à§ã§î Y painter->drawLine(cX,cY,cX+4,cY+10); //§ã§ä§â§Ö§Ý§Ü§Ú painter->drawLine(cX,cY,cX-4,cY+10); painter->drawLine(cX,cY+cH,cX+cW,cY+cH); //§à§ã§î §· } return 0; }
QList< Model::Link* > Model::DjVuPage::links() const { QMutexLocker mutexLocker(&m_parent->m_mutex); QList< Link* > links; miniexp_t pageAnnoExp; while(true) { pageAnnoExp = ddjvu_document_get_pageanno(m_parent->m_document, m_index); if(pageAnnoExp == miniexp_dummy) { clearMessageQueue(m_parent->m_context, true); } else { break; } } const int pageAnnoLength = miniexp_length(pageAnnoExp); for(int pageAnnoN = 0; pageAnnoN < pageAnnoLength; ++pageAnnoN) { miniexp_t linkExp = miniexp_nth(pageAnnoN, pageAnnoExp); if(miniexp_length(linkExp) <= 3 || qstrncmp(miniexp_to_name(miniexp_nth(0, linkExp)), "maparea", 7 ) != 0 || !miniexp_symbolp(miniexp_nth(0, miniexp_nth(3, linkExp)))) { continue; } const QString type = QString::fromUtf8(miniexp_to_name(miniexp_nth(0, miniexp_nth(3, linkExp)))); if(type == QLatin1String("rect") || type == QLatin1String("oval") || type == QLatin1String("poly")) { // boundary QPainterPath boundary; miniexp_t areaExp = miniexp_nth(3, linkExp); const int areaLength = miniexp_length( areaExp ); if(areaLength == 5 && (type == QLatin1String("rect") || type == QLatin1String("oval"))) { QPoint p(miniexp_to_int(miniexp_nth(1, areaExp)), miniexp_to_int(miniexp_nth(2, areaExp))); QSize s(miniexp_to_int(miniexp_nth(3, areaExp)), miniexp_to_int(miniexp_nth(4, areaExp))); p.setY(m_size.height() - s.height() - p.y()); const QRectF r(p, s); if(type == QLatin1String("rect")) { boundary.addRect(r); } else { boundary.addEllipse(r); } } else if(areaLength > 0 && areaLength % 2 == 1 && type == QLatin1String("poly")) { QPolygon polygon; for(int areaExpN = 1; areaExpN < areaLength; areaExpN += 2) { QPoint p(miniexp_to_int(miniexp_nth(areaExpN, areaExp)), miniexp_to_int(miniexp_nth(areaExpN + 1, areaExp))); p.setY(m_size.height() - p.y()); polygon << p; } boundary.addPolygon(polygon); } if(boundary.isEmpty()) { continue; } boundary = QTransform::fromScale(1.0 / m_size.width(), 1.0 / m_size.height()).map(boundary); // target QString target; miniexp_t targetExp = miniexp_nth(1, linkExp); if(miniexp_stringp(targetExp)) { target = QString::fromUtf8(miniexp_to_str(miniexp_nth(1, linkExp))); } else if(miniexp_length(targetExp) == 3 && qstrncmp(miniexp_to_name(miniexp_nth(0, targetExp)), "url", 3) == 0) { target = QString::fromUtf8(miniexp_to_str(miniexp_nth(1, targetExp))); } if(target.isEmpty()) { continue; } if(target.at(0) == QLatin1Char('#')) { target.remove(0, 1); bool ok = false; int targetPage = target.toInt(&ok); if(!ok) { if(m_parent->m_indexByName.contains(target)) { targetPage = m_parent->m_indexByName[target] + 1; } else { continue; } } else { targetPage = (target.at(0) == QLatin1Char('+') || target.at(0) == QLatin1Char('-')) ? m_index + targetPage : targetPage; } links.append(new Link(boundary, targetPage)); } else { links.append(new Link(boundary, target)); } } } ddjvu_miniexp_release(m_parent->m_document, pageAnnoExp); return links; }
QString VariantHandler::displayString(const QVariant& value) { switch (value.type()) { #ifndef QT_NO_CURSOR case QVariant::Cursor: { const QCursor cursor = value.value<QCursor>(); return Util::enumToString(QVariant::fromValue<int>(cursor.shape()), "Qt::CursorShape"); } #endif case QVariant::Icon: { const QIcon icon = value.value<QIcon>(); if (icon.isNull()) { return QObject::tr("<no icon>"); } QStringList l; foreach (const QSize &size, icon.availableSizes()) { l.push_back(displayString(size)); } return l.join(QLatin1String(", ")); } case QVariant::Line: return QString::fromUtf8("%1 x %2 → %3 x %4"). arg(value.toLine().x1()).arg(value.toLine().y1()). arg(value.toLine().x2()).arg(value.toLine().y2()); case QVariant::LineF: return QString::fromUtf8("%1 x %2 → %3 x %4"). arg(value.toLineF().x1()).arg(value.toLineF().y1()). arg(value.toLineF().x2()).arg(value.toLineF().y2()); case QVariant::Locale: return value.value<QLocale>().name(); case QVariant::Point: return QString::fromLatin1("%1x%2"). arg(value.toPoint().x()). arg(value.toPoint().y()); case QVariant::PointF: return QString::fromLatin1("%1x%2"). arg(value.toPointF().x()). arg(value.toPointF().y()); case QVariant::Rect: return QString::fromLatin1("%1x%2 %3x%4"). arg(value.toRect().x()). arg(value.toRect().y()). arg(value.toRect().width()). arg(value.toRect().height()); case QVariant::RectF: return QString::fromLatin1("%1x%2 %3x%4"). arg(value.toRectF().x()). arg(value.toRectF().y()). arg(value.toRectF().width()). arg(value.toRectF().height()); case QVariant::Region: { const QRegion region = value.value<QRegion>(); if (region.isEmpty()) { return QLatin1String("<empty>"); } if (region.rectCount() == 1) { return displayString(region.rects().first()); } else { return QString::fromLatin1("<%1 rects>").arg(region.rectCount()); } } case QVariant::Palette: { const QPalette pal = value.value<QPalette>(); if (pal == qApp->palette()) { return QLatin1String("<inherited>"); } return QLatin1String("<custom>"); } case QVariant::Size: return QString::fromLatin1("%1x%2"). arg(value.toSize().width()). arg(value.toSize().height()); case QVariant::SizeF: return QString::fromLatin1("%1x%2"). arg(value.toSizeF().width()). arg(value.toSizeF().height()); case QVariant::StringList: return value.toStringList().join(", "); case QVariant::Transform: { const QTransform t = value.value<QTransform>(); return QString::fromLatin1("[%1 %2 %3, %4 %5 %6, %7 %8 %9]"). arg(t.m11()).arg(t.m12()).arg(t.m13()). arg(t.m21()).arg(t.m22()).arg(t.m23()). arg(t.m31()).arg(t.m32()).arg(t.m33()); } default: break; } // types with dynamic type ids if (value.type() == (QVariant::Type)qMetaTypeId<QTextLength>()) { const QTextLength l = value.value<QTextLength>(); QString typeStr; switch (l.type()) { case QTextLength::VariableLength: typeStr = QObject::tr("variable"); break; case QTextLength::FixedLength: typeStr = QObject::tr("fixed"); break; case QTextLength::PercentageLength: typeStr = QObject::tr("percentage"); break; } return QString::fromLatin1("%1 (%2)").arg(l.rawValue()).arg(typeStr); } if (value.userType() == qMetaTypeId<QPainterPath>()) { const QPainterPath path = value.value<QPainterPath>(); if (path.isEmpty()) { return QObject::tr("<empty>"); } return QObject::tr("<%1 elements>").arg(path.elementCount()); } if (value.userType() == qMetaTypeId<QMargins>()) { const QMargins margins = value.value<QMargins>(); return QObject::tr("left: %1, top: %2, right: %3, bottom: %4") .arg(margins.left()).arg(margins.top()) .arg(margins.right()).arg(margins.bottom()); } if (value.canConvert<QObject*>()) { return Util::displayString(value.value<QObject*>()); } #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) if (value.userType() == qMetaTypeId<QSet<QByteArray> >()) { const QSet<QByteArray> set = value.value<QSet<QByteArray> >(); QStringList l; foreach (const QByteArray &b, set) l.push_back(QString::fromUtf8(b)); return l.join(", "); } if (value.userType() == qMetaTypeId<QSurfaceFormat>()) { const QSurfaceFormat format = value.value<QSurfaceFormat>(); QString s; switch (format.renderableType()) { case QSurfaceFormat::DefaultRenderableType: s += "Default"; break; case QSurfaceFormat::OpenGL: s += "OpenGL"; break; case QSurfaceFormat::OpenGLES: s += "OpenGL ES"; break; case QSurfaceFormat::OpenVG: s += "OpenVG"; break; } s += " (" + QString::number(format.majorVersion()) + "." + QString::number(format.minorVersion()); switch (format.profile()) { case QSurfaceFormat::CoreProfile: s += " core"; break; case QSurfaceFormat::CompatibilityProfile: s += " compat"; break; case QSurfaceFormat::NoProfile: break; } s += ")"; s += " RGBA: " + QString::number(format.redBufferSize()) + "/" + QString::number(format.greenBufferSize()) + "/" + QString::number(format.blueBufferSize()) + "/" + QString::number(format.alphaBufferSize()); s += " Depth: " + QString::number(format.depthBufferSize()); s += " Stencil: " + QString::number(format.stencilBufferSize()); s += " Buffer: "; switch (format.swapBehavior()) { case QSurfaceFormat::DefaultSwapBehavior: s += "default"; break; case QSurfaceFormat::SingleBuffer: s += "single"; break; case QSurfaceFormat::DoubleBuffer: s += "double"; break; case QSurfaceFormat::TripleBuffer: s += "triple"; break; default: s += "unknown"; } return s; } if (value.userType() == qMetaTypeId<QSurface::SurfaceClass>()) { const QSurface::SurfaceClass sc = value.value<QSurface::SurfaceClass>(); switch (sc) { case QSurface::Window: return QObject::tr("Window"); #if QT_VERSION > QT_VERSION_CHECK(5, 1, 0) case QSurface::Offscreen: return QObject::tr("Offscreen"); #endif default: return QObject::tr("Unknown Surface Class"); } } if (value.userType() == qMetaTypeId<QSurface::SurfaceType>()) { const QSurface::SurfaceType type = value.value<QSurface::SurfaceType>(); switch (type) { case QSurface::RasterSurface: return QObject::tr("Raster"); case QSurface::OpenGLSurface: return QObject::tr("OpenGL"); default: return QObject::tr("Unknown Surface Type"); } } #endif // enums const QString enumStr = Util::enumToString(value); if (!enumStr.isEmpty()) { return enumStr; } // custom converters const QHash<int, Converter<QString>*>::const_iterator it = s_variantHandlerRepository()->stringConverters.constFind(value.userType()); if (it != s_variantHandlerRepository()->stringConverters.constEnd()) { return (*it.value())(value); } return value.toString(); }
void QOutlineMapper::endOutline() { closeSubpath(); if (m_elements.isEmpty()) { memset(&m_outline, 0, sizeof(m_outline)); return; } QPointF *elements = m_elements.data(); // Transform the outline if (m_txop == QTransform::TxNone) { // Nothing to do. } else if (m_txop == QTransform::TxTranslate) { for (int i = 0; i < m_elements.size(); ++i) { QPointF &e = elements[i]; e = QPointF(e.x() + m_dx, e.y() + m_dy); } } else if (m_txop == QTransform::TxScale) { for (int i = 0; i < m_elements.size(); ++i) { QPointF &e = elements[i]; e = QPointF(m_m11 * e.x() + m_dx, m_m22 * e.y() + m_dy); } } else if (m_txop < QTransform::TxProject) { for (int i = 0; i < m_elements.size(); ++i) { QPointF &e = elements[i]; e = QPointF(m_m11 * e.x() + m_m21 * e.y() + m_dx, m_m22 * e.y() + m_m12 * e.x() + m_dy); } } else { const QVectorPath vp((qreal *)elements, m_elements.size(), m_element_types.size() ? m_element_types.data() : 0); QPainterPath path = vp.convertToPainterPath(); path = QTransform(m_m11, m_m12, m_m13, m_m21, m_m22, m_m23, m_dx, m_dy, m_m33).map(path); if (!(m_outline.flags & QT_FT_OUTLINE_EVEN_ODD_FILL)) path.setFillRule(Qt::WindingFill); uint old_txop = m_txop; m_txop = QTransform::TxNone; if (path.isEmpty()) m_valid = false; else convertPath(path); m_txop = old_txop; return; } if (m_round_coords) { // round coordinates to match outlines drawn with drawLine_midpoint_i for (int i = 0; i < m_elements.size(); ++i) elements[i] = QPointF(qFloor(elements[i].x() + aliasedCoordinateDelta), qFloor(elements[i].y() + aliasedCoordinateDelta)); } controlPointRect = boundingRect(elements, m_elements.size()); #ifdef QT_DEBUG_CONVERT printf(" - control point rect (%.2f, %.2f) %.2f x %.2f, clip=(%d,%d, %dx%d)\n", controlPointRect.x(), controlPointRect.y(), controlPointRect.width(), controlPointRect.height(), m_clip_rect.x(), m_clip_rect.y(), m_clip_rect.width(), m_clip_rect.height()); #endif // Check for out of dev bounds... const bool do_clip = !m_in_clip_elements && ((controlPointRect.left() < -QT_RASTER_COORD_LIMIT || controlPointRect.right() > QT_RASTER_COORD_LIMIT || controlPointRect.top() < -QT_RASTER_COORD_LIMIT || controlPointRect.bottom() > QT_RASTER_COORD_LIMIT || controlPointRect.width() > QT_RASTER_COORD_LIMIT || controlPointRect.height() > QT_RASTER_COORD_LIMIT)); if (do_clip) { clipElements(elements, elementTypes(), m_elements.size()); } else { convertElements(elements, elementTypes(), m_elements.size()); } }
void TemporalConstraintView::paint( QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget) { // Draw the rack bg if(auto rack = presenter().rack()) { auto rackRect = rack->view().boundingRect(); painter->fillRect(rackRect, QColor::fromRgba(qRgba(0, 127, 229, 76))); auto color = qApp->palette("ScenarioPalette").base().color(); QPen pen{color, 2, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin}; painter->setPen(pen); painter->drawLine(rackRect.topLeft(), rackRect.bottomLeft()); painter->drawLine(rackRect.topRight(), rackRect.bottomRight()); } QPainterPath solidPath, dashedPath, leftBrace, rightBrace; // m_endState->setPos(defaultWidth(), 0); // Paths if(infinite()) { if(minWidth() != 0) { solidPath.lineTo(minWidth(), 0); leftBrace.moveTo(minWidth(), -10); leftBrace.arcTo(minWidth() - 10, -10, 20, 20, 90, 180); } // TODO end state should be hidden dashedPath.moveTo(minWidth(), 0); dashedPath.lineTo(defaultWidth(), 0); } else if(minWidth() == maxWidth()) // TODO rigid() { solidPath.lineTo(defaultWidth(), 0); } else { if(minWidth() != 0) solidPath.lineTo(minWidth(), 0); dashedPath.moveTo(minWidth(), 0); dashedPath.lineTo(maxWidth(), 0); leftBrace.moveTo(minWidth(), -10); leftBrace.arcTo(minWidth() - 10, -10, 20, 20, 90, 180); rightBrace.moveTo(maxWidth(), 10); rightBrace.arcTo(maxWidth() - 10, -10, 20, 20, 270, 180); } QPainterPath playedPath; if(playWidth() != 0) { playedPath.lineTo(playWidth(), 0); } // Colors QColor constraintColor; if(isSelected()) { constraintColor = QColor::fromRgbF(0.188235, 0.54902, 0.776471); } else { constraintColor = qApp->palette("ScenarioPalette").base().color(); } if(warning()) { constraintColor = QColor{200,150,0}; } if(! isValid()) { constraintColor = Qt::red; } m_solidPen.setColor(constraintColor); m_dashPen.setColor(constraintColor); // Drawing painter->setPen(m_solidPen); if(!solidPath.isEmpty()) painter->drawPath(solidPath); if(!leftBrace.isEmpty()) painter->drawPath(leftBrace); if(!rightBrace.isEmpty()) painter->drawPath(rightBrace); painter->setPen(m_dashPen); if(!dashedPath.isEmpty()) painter->drawPath(dashedPath); leftBrace.closeSubpath(); rightBrace.closeSubpath(); QPen anotherPen(Qt::transparent, 4); painter->setPen(anotherPen); QColor blueish = m_solidPen.color().lighter(); blueish.setAlphaF(0.3); painter->setBrush(blueish); painter->drawPath(leftBrace); painter->drawPath(rightBrace); static const QPen playedPen{ QBrush{Qt::green}, 4, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin }; static const QPen dashedPlayedPen{ QBrush{Qt::green}, 4, Qt::DashLine, Qt::RoundCap, Qt::RoundJoin }; painter->setPen(playedPen); if(!playedPath.isEmpty()) painter->drawPath(playedPath); int fontSize = 12; QRectF labelRect{0,0, defaultWidth(), (-fontSize - 2.)}; QFont f("Ubuntu"); f.setPixelSize(fontSize); painter->setFont(f); painter->setPen(m_labelColor); painter->drawText(labelRect, Qt::AlignCenter, m_label); /* painter->setPen(Qt::darkRed); painter->setBrush(Qt::NoBrush); painter->drawRect(boundingRect()); */ }
void QPaintEngineEx::drawPath(const QPainterPath &path) { if (!path.isEmpty()) draw(qtVectorPathForPath(path)); }
void TemporalConstraintView::paint( QPainter* painter, const QStyleOptionGraphicsItem*, QWidget*) { qreal min_w = minWidth(); qreal max_w = maxWidth(); qreal def_w = defaultWidth(); qreal play_w = playWidth(); // Draw the stuff present if there is a rack *in the model* ? if(presenter().rack()) { // Background auto rect = boundingRect(); rect.adjust(0,15,0,-10); rect.setWidth(this->defaultWidth()); painter->fillRect(rect, m_bgColor); // Fake timenode continuation auto color = ScenarioStyle::instance().RackSideBorder; QPen pen{color, 2, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin}; painter->setPen(pen); painter->drawLine(rect.topLeft(), rect.bottomLeft()); painter->drawLine(rect.topRight(), rect.bottomRight()); } QPainterPath solidPath, dashedPath, leftBrace, rightBrace; // Paths if(infinite()) { if(min_w != 0.) { solidPath.lineTo(min_w, 0); leftBrace.moveTo(min_w, -10); leftBrace.arcTo(min_w - 10, -10, 20, 20, 90, 180); } // TODO end state should be hidden dashedPath.moveTo(min_w, 0); dashedPath.lineTo(def_w, 0); } else if(min_w == max_w) // TODO rigid() { solidPath.lineTo(def_w, 0); } else { if(min_w != 0.) solidPath.lineTo(min_w, 0); dashedPath.moveTo(min_w, 0); dashedPath.lineTo(max_w, 0); leftBrace.moveTo(min_w + 10, -10); leftBrace.arcTo(min_w, -10, 20, 20, 90, 180); leftBrace.closeSubpath(); rightBrace.moveTo(max_w, 10); rightBrace.arcTo(max_w - 10, -10, 20, 20, 270, 180); rightBrace.closeSubpath(); rightBrace.translate(-10, 0); // TODO bleh. } QPainterPath playedPath; if(play_w != 0.) { playedPath.lineTo(play_w, 0); } // Colors QColor constraintColor; // TODO make a switch instead if(isSelected()) { constraintColor = ScenarioStyle::instance().ConstraintSelected; } else if(warning()) { constraintColor = ScenarioStyle::instance().ConstraintWarning; } else { constraintColor = ScenarioStyle::instance().ConstraintBase; } if(! isValid()) { constraintColor = ScenarioStyle::instance().ConstraintInvalid; this->setZValue(this->zValue()+ 1); } else { this->setZValue(parentObject()->zValue() + 3); } m_solidPen.setColor(constraintColor); m_dashPen.setColor(constraintColor); // Drawing painter->setPen(m_solidPen); if(!solidPath.isEmpty()) painter->drawPath(solidPath); if(!leftBrace.isEmpty()) painter->drawPath(leftBrace); if(!rightBrace.isEmpty()) painter->drawPath(rightBrace); painter->setPen(m_dashPen); if(!dashedPath.isEmpty()) painter->drawPath(dashedPath); leftBrace.closeSubpath(); rightBrace.closeSubpath(); QPen anotherPen(Qt::transparent, 4); painter->setPen(anotherPen); QColor blueish = m_solidPen.color().lighter(); blueish.setAlphaF(0.3); painter->setBrush(blueish); painter->drawPath(leftBrace); painter->drawPath(rightBrace); static const QPen playedPen{ QBrush{ScenarioStyle::instance().ConstraintPlayFill}, 4, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin }; painter->setPen(playedPen); if(!playedPath.isEmpty()) painter->drawPath(playedPath); static const int fontSize = 12; QRectF labelRect{0,0, defaultWidth(), (-fontSize - 2.)}; auto f = ProcessFonts::Sans(); f.setPointSize(fontSize); painter->setFont(f); painter->setPen(m_labelColor); painter->drawText(labelRect, Qt::AlignCenter, m_label); #if defined(ISCORE_SCENARIO_DEBUG_RECTS) painter->setPen(Qt::darkRed); painter->setBrush(Qt::NoBrush); painter->drawRect(boundingRect()); #endif }
void NMGChartSeries::paintArea(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget) { int maxValuesInPartialPath = 1000; QColor hsv = baseColor.toHsv(); hsv.setHsv(hsv.hue(), (int)(hsv.saturation()*0.25), hsv.value()); if(isAveraged || isAccumulated) { painter->setBrush(hsv); paintLine(painter, option, widget); } else { // not average nor accumulated /* NOTE A specific implementation is needed in this case because Graphics View doesn't * support correctly huge amount of points (X11 crashes). The design has been based in * partial paths that are painted with brush (to paint the area), and later they are * added to the complete path (to paint the boundary line).*/ painter->setPen(Qt::NoPen); painter->setBrush(hsv); QPainterPath completedPath; double closingYpixel = ((minValues.y < 0.0 && 0.0 < maxValues.y) ? yWindowToViewport(0.0) : ((minValues.y >= 0.0) ? yWindowToViewport(minValues.y) : yWindowToViewport(maxValues.y))); QList<Vertex>::const_iterator it = vertexList.constBegin(); do { QPainterPath partialPath; QPainterPath partialPathModif; partialPath.moveTo(xWindowToViewport(it->x), -yWindowToViewport(it->y)); for(int i = 1; i <= maxValuesInPartialPath && it != vertexList.constEnd(); i++, it++) { partialPath.lineTo(xWindowToViewport(it->x),-yWindowToViewport(it->y)); } if(completedPath.isEmpty()) { partialPathModif = partialPath; partialPathModif.lineTo(partialPathModif.currentPosition().rx(), -closingYpixel); partialPathModif.lineTo(xWindowToViewport(vertexList.first().x), -closingYpixel); completedPath = partialPath; } else { partialPathModif = partialPath; partialPathModif.lineTo(partialPath.currentPosition().rx(), -closingYpixel); partialPathModif.lineTo(completedPath.currentPosition().rx(), -closingYpixel); partialPathModif.lineTo(completedPath.currentPosition().rx(), completedPath.currentPosition().ry()); completedPath.connectPath(partialPath); } partialPathModif.closeSubpath(); painter->drawPath(partialPathModif); } while(it != vertexList.constEnd()); painter->setPen(Qt::SolidLine); painter->setPen(baseColor); painter->setBrush(Qt::NoBrush); completedPath.lineTo(xWindowToViewport(vertexList.last().x), -closingYpixel); completedPath.lineTo(xWindowToViewport(vertexList.first().x), -closingYpixel); completedPath.closeSubpath(); painter->drawPath(completedPath); } }