/** * @return The shape of the AssociationLine. */ QPainterPath AssociationLine::shape() const { QPainterPathStroker stroker; stroker.setWidth(qMax<qreal>(2*SelectedPointDiameter, pen().widthF()) + 2.0); // allow delta region stroker.setCapStyle(Qt::FlatCap); return stroker.createStroke(path()); }
QPainterPath GEdge::shape() const { QPainterPath path(sourcePoint); QPainterPathStroker stroker; path.lineTo(destPoint); stroker.setWidth(20); return stroker.createStroke(path); }
QPainterPath Line::shape() const { // sets the shape of the line for selection QPainterPathStroker stroker; stroker.setWidth(10); return stroker.createStroke(path); }
qreal PortHandler::linePortId(const QPointF &location, const QStringList &types) const { for (int linePortNumber = 0; linePortNumber < mLinePorts.count(); linePortNumber++) { const StatLine * const linePort = mLinePorts.at(linePortNumber); if (!types.contains(linePort->type())) { continue; } QPainterPathStroker ps; ps.setWidth(kvadratik - 5); QPainterPath path; const QLineF line = transformPortForNodeSize(linePort); path.moveTo(line.p1()); path.lineTo(line.p2()); path = ps.createStroke(path); if (path.contains(location)) { return linePortNumber + mPointPorts.size() + qMin(QLineF(line.p1(), location).length() / line.length() , mMaximumFractionPartValue); } } return nonexistentPortId; }
static inline QRectF boundsOnStroke(const QPainterPath &path, qreal width) { QPainterPathStroker stroker; stroker.setWidth(width); QPainterPath stroke = stroker.createStroke(path); return stroke.boundingRect(); }
void LineObject::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* /*widget*/) { QGraphicsScene* objScene = scene(); if(!objScene) return; QPen paintPen = pen(); painter->setPen(paintPen); updateRubber(painter); if(option->state & QStyle::State_Selected) { paintPen.setStyle(Qt::DashLine); } if(objScene->property(ENABLE_LWT).toBool()) { paintPen = lineWeightPen(); } painter->setPen(paintPen); if(objectRubberMode() != OBJ_RUBBER_LINE) painter->drawLine(line()); //TODO: This is the initial concept for what realistic rendering be like. It's somewhat decent but needs improvement. if(objScene->property(ENABLE_LWT).toBool() && objScene->property(ENABLE_REAL).toBool()) { painter->setPen(objectColor().darker(150)); //TODO: Improve this for black and dark colors QPainterPathStroker stroker; stroker.setWidth(0.35); stroker.setCapStyle(Qt::RoundCap); stroker.setJoinStyle(Qt::RoundJoin); QPainterPath realPath = stroker.createStroke(path()); painter->drawPath(realPath); QLinearGradient grad(mapFromScene(objectMidPoint()), mapFromScene(objectEndPoint1())); grad.setColorAt(0, objectColor()); grad.setColorAt(1, objectColor().darker(150)); //TODO: Improve this for black and dark colors grad.setSpread(QGradient::ReflectSpread); painter->fillPath(realPath, QBrush(grad)); } }
QPainterPath TournamentArcDraw::shape() const { QPainterPath path; QPointF p1 = mapFromItem(_tail, 0, 0); QPointF p2 = mapFromItem(_head, 0, 0); double x1 = p1.x(); double x2 = p2.x(); if(x1 > x2) { qSwap(p1, p2); qSwap(x1, x2); } // TODO: Fix this, then make it selectable path.moveTo(p2); //path.lineTo(x1-2, 10); //path.addRect(0, 0, 20, 20); int height = (x2 - x1) / 4; int startAngle = 0; int spanAngle = 180; path.arcTo(QRectF(QPointF(x1, -height), QPointF(x2, height)), startAngle, spanAngle); path.arcTo(QRectF(QPointF(x1, -height), QPointF(x2, height)), spanAngle, -spanAngle); QPainterPathStroker stroker; stroker.setWidth(6); return stroker.createStroke(path); }
static QPainterPath getPathStroke(const QPainterPath &path, const RenderObject* object, const RenderStyle* style) { QPainterPathStroker s; s.setWidth(KSVGPainterFactory::cssPrimitiveToLength(object, style->svgStyle()->strokeWidth(), 1.0)); if (style->svgStyle()->capStyle() == ButtCap) s.setCapStyle(Qt::FlatCap); else if (style->svgStyle()->capStyle() == RoundCap) s.setCapStyle(Qt::RoundCap); if (style->svgStyle()->joinStyle() == MiterJoin) { s.setJoinStyle(Qt::MiterJoin); s.setMiterLimit((qreal) style->svgStyle()->strokeMiterLimit()); } else if(style->svgStyle()->joinStyle() == RoundJoin) s.setJoinStyle(Qt::RoundJoin); const KCDashArray& dashes = KSVGPainterFactory::dashArrayFromRenderingStyle(style); double dashOffset = KSVGPainterFactory::cssPrimitiveToLength(object, style->svgStyle()->strokeDashOffset(), 0.0); unsigned int dashLength = !dashes.isEmpty() ? dashes.size() : 0; if(dashLength) { QVector<qreal> pattern; unsigned int count = (dashLength % 2) == 0 ? dashLength : dashLength * 2; for(unsigned int i = 0; i < count; i++) pattern.append(dashes[i % dashLength] / (float)s.width()); s.setDashPattern(pattern); Q_UNUSED(dashOffset); // TODO: dash-offset, does/will qt4 API allow it? (Rob) } return s.createStroke(path); }
static inline QRectF boundsOnStroke(QPainter *p, const QPainterPath &path, qreal width) { QPainterPathStroker stroker; stroker.setWidth(width); QPainterPath stroke = stroker.createStroke(path); return p->transform().map(stroke).boundingRect(); }
QPainterPath ArrowLinkItem::shape() const { QPainterPath path = originalShape(); QPainterPathStroker pathStroker; pathStroker.setWidth(10); return pathStroker.createStroke(path); }
qreal PortHandler::circularPortId(const QPointF &location, const QStringList &types) const { for (int circularPortNumber = 0; circularPortNumber < mCircularPorts.count(); circularPortNumber++) { const StatCircular * const circularPort = mCircularPorts.at(circularPortNumber); if (!types.contains(circularPort->type())) { continue; } QPainterPathStroker ps; ps.setWidth(kvadratik); QPainterPath path; StatCircular::CircularPort circular = transformPortForNodeSize(circularPort); path.addEllipse({circular.x, circular.y}, circular.rx, circular.ry); path = ps.createStroke(path); if (path.contains(location)) { return circularPortNumber + mPointPorts.size() + mLinePorts.size() + (pointByCircularPortAngle(circularPortNumber, location) / 360.0); } } return nonexistentPortId; }
QPainterPath EdgeItem::shape() const { QPainterPath path( srcP); QPainterPathStroker stroker; if ( srcP == dstP) return path; if ( edge()->isSelf()) { path = selfEdgePath(); } else { path.cubicTo( cp1, cp2, dstP); } if ( isNotNullP( edge()->style())) { stroker.setWidth( edge()->style()->pen().width() + 1); } else { stroker.setWidth( 2); } return stroker.createStroke( path); }
QGraphicsItemGroup *ProfileGraphicsView::plot_text(text_render_options_t *tro,const QPointF& pos, const QString& text, QGraphicsItem *parent) { QFont fnt(font()); QFontMetrics fm(fnt); if (printMode) fnt.setPixelSize(tro->size); QPointF point(SCALEGC(pos.x(), pos.y())); // This is neded because of the SCALE macro. double dx = tro->hpos * (fm.width(text)); double dy = tro->vpos * (fm.height()); QGraphicsItemGroup *group = new QGraphicsItemGroup(parent); QPainterPath textPath; /* addText() uses bottom-left text baseline and the -3 offset is probably slightly off * for different font sizes. */ textPath.addText(0, fm.height() - 3, fnt, text); QPainterPathStroker stroker; stroker.setWidth(3); QGraphicsPathItem *strokedItem = new QGraphicsPathItem(stroker.createStroke(textPath), group); strokedItem->setBrush(QBrush(getColor(TEXT_BACKGROUND))); strokedItem->setPen(Qt::NoPen); QGraphicsPathItem *textItem = new QGraphicsPathItem(textPath, group); textItem->setBrush(QBrush(getColor(tro->color))); textItem->setPen(Qt::NoPen); group->setPos(point.x() + dx, point.y() + dy); if (!printMode) group->setFlag(QGraphicsItem::ItemIgnoresTransformations); if (!parent) scene()->addItem(group); return group; }
/** * Shape */ QPainterPath GuiEdge::shape() const { // QPainterPath path( edge_start_point_priv); QPainterPathStroker stroker; // path.lineTo( edge_end_point_priv.x(), edge_end_point_priv.y()); stroker.setWidth( 10); return stroker.createStroke( edge_curve_priv); }
QPainterPath GraphicsItemEdge::shape() const { QPainterPathStroker stroker; stroker.setWidth(g_settings->edgeWidth); stroker.setCapStyle(Qt::RoundCap); stroker.setJoinStyle(Qt::RoundJoin); return stroker.createStroke(path()); }
void tst_QPainterPathStroker::strokeEmptyPath() { QPainterPath path; path.moveTo(10, 10); path.lineTo(10, 10); QPainterPathStroker stroker; QCOMPARE(stroker.createStroke(path), path); }
QRectF Connection::boundingRect() const { if (!areInspectorsValid()) return QRectF(); QPainterPathStroker s; s.setWidth(20); return s.createStroke(path()).boundingRect(); }
QPainterPath LatexArrow::contour(qreal width) const { QPainterPathStroker stroker; stroker.setJoinStyle(Qt::RoundJoin); stroker.setCapStyle(Qt::RoundCap); stroker.setWidth(width); return stroker.createStroke(path()); }
QPainterPath GraphicsItemNode::shape() const { //If there is only one segment and it is shorter than half its //width, then the arrow head will not be made with 45 degree //angles, but rather whatever angle is made by going from the //end to the back corners (the final node will be a triangle). if (m_hasArrow && m_linePoints.size() == 2 && distance(getLast(), getSecondLast()) < m_width / 2.0) { QLineF backline = QLineF(getSecondLast(), getLast()).normalVector(); backline.setLength(m_width / 2.0); QPointF backVector = backline.p2() - backline.p1(); QPainterPath trianglePath; trianglePath.moveTo(getLast()); trianglePath.lineTo(getSecondLast() + backVector); trianglePath.lineTo(getSecondLast() - backVector); trianglePath.lineTo(getLast()); return trianglePath; } //Create a path that outlines the main node shape. QPainterPathStroker stroker; stroker.setWidth(m_width); stroker.setCapStyle(Qt::FlatCap); stroker.setJoinStyle(Qt::RoundJoin); QPainterPath mainNodePath = stroker.createStroke(path()); if (!m_hasArrow) return mainNodePath; //If the node has an arrow head, subtract the part of its //final segment to give it a pointy end. //NOTE: THIS APPROACH CAN LEAD TO WEIRD EFFECTS WHEN THE NODE'S //POINTY END OVERLAPS WITH ANOTHER PART OF THE NODE. PERHAPS THERE //IS A BETTER WAY TO MAKE ARROWHEADS? QLineF frontline = QLineF(getLast(), getSecondLast()).normalVector(); frontline.setLength(m_width / 2.0); QPointF frontVector = frontline.p2() - frontline.p1(); QLineF arrowheadLine(getLast(), getSecondLast()); arrowheadLine.setLength(1.42 * (m_width / 2.0)); arrowheadLine.setAngle(arrowheadLine.angle() + 45.0); QPointF arrow1 = arrowheadLine.p2(); arrowheadLine.setAngle(arrowheadLine.angle() - 90.0); QPointF arrow2 = arrowheadLine.p2(); QLineF lastSegmentLine(getSecondLast(), getLast()); lastSegmentLine.setLength(0.01); QPointF additionalForwardBit = lastSegmentLine.p2() - lastSegmentLine.p1(); QPainterPath subtractionPath; subtractionPath.moveTo(getLast()); subtractionPath.lineTo(arrow1); subtractionPath.lineTo(getLast() + frontVector + additionalForwardBit); subtractionPath.lineTo(getLast() - frontVector + additionalForwardBit); subtractionPath.lineTo(arrow2); subtractionPath.lineTo(getLast()); return mainNodePath.subtracted(subtractionPath); }
QPainterPath Line::shape() const { QPainterPath path; path.moveTo(line().p1()); path.lineTo(line().p2()); QPainterPathStroker stroker; stroker.setWidth(100); stroker.setCapStyle(Qt::FlatCap); return stroker.createStroke(path); }
QPainterPath BoundRegion::shape() const { if (!mStroke) { return mBoundItem.shape(); } QPainterPathStroker stroker; stroker.setWidth(mStroke); return stroker.createStroke(mBoundItem.shape()); }
void WallItem::recalculateBorders() { QPainterPath wallPath; wallPath.moveTo(begin()); wallPath.lineTo(end()); QPainterPathStroker stroker; stroker.setWidth(wallWidth * 3 / 2); mPath = stroker.createStroke(wallPath); }
/** * @brief PartTerminal::shape * @return the shape of this item */ QPainterPath PartTerminal::shape() const { QPainterPath shape; shape.lineTo(second_point); QPainterPathStroker pps; pps.setWidth(1); return (pps.createStroke(shape)); }
QRectF EdgeItem::boundingRect() const { //qDebug("rect"); // QRectF r = m_path.boundingRect(); // qDebug()<<(void*)this<<" left "<<r.left()<<" top "<<r.top()<<" width "<<r.width()<<" height "<<r.height(); QPainterPathStroker s; s.setWidth(20); return s.createStroke( path() ).boundingRect(); //QRectF(0,0, 20*m_curve,m_p1.x() - m_p0.x());// }
void PainterBezier::updatePath() { QPainterPath bezierPath; bezierPath.moveTo(m_p1); bezierPath.cubicTo( m_p2, m_p3, m_p4 ); QPainterPathStroker outliner; outliner.setWidth(m_FillWidth); outliner.setCapStyle( Qt::FlatCap ); m_Path = outliner.createStroke(bezierPath); }
QPainterPath QtArrowItem::shape() const { //Thanks to norobro for posting this code at //http://www.qtcentre.org/threads/49201-Increase-margin-for-detecting-tooltip-events-of-QGraphicsLineItem QPainterPath path; QPainterPathStroker stroker; path.moveTo(line().p1()); path.lineTo(line().p2()); stroker.setWidth(10); return stroker.createStroke(path); }
QPainterPath WorldModel::buildWallPath() const { // TODO: Maintain a cache for this. QPainterPathStroker pathStroker; pathStroker.setWidth(3); QPainterPath wallPath; foreach (WallItem* wall, mWalls) { wallPath.moveTo(wall->begin()); wallPath.lineTo(wall->end()); }
bool WorldModel::checkCollision(QPolygonF const &robotRegion) const { QPainterPath robotPath; robotPath.addPolygon(robotRegion); QPainterPathStroker pathStroker; pathStroker.setWidth(3); robotPath = pathStroker.createStroke(robotPath); QPainterPath wallPath = buildWallPath(); return wallPath.intersects(robotPath); }
void GraphicsArrowProgram::addRule(AbstractRulePtr abstract) { ConfigurationStack &stack=ConfigurationStack::instance(); //Append the rule to our list _rules << abstract; //Reset the tooltip Program program=stack.current().getProgramByName(_app_name, true); QString tooltip="<big><b>"+program.displayName()+"</b></big>"; QVectorIterator<AbstractRulePtr> i(_rules); while(i.hasNext()) { AbstractRulePtr rule=i.next(); QVectorIterator<MRule> j(rule->mRules()); tooltip+="<br />"+rule->displayName(); while(j.hasNext()) tooltip+="<br /> - "+j.next().displayName(); } setToolTip(tooltip); //If the rule has warnings, calculate the new warning type of the arrow program if(stack.ruleHasWarnings(abstract->id()) && EditorConfig::outlineArrowPrograms() && _parent) { _warning_type|=stack.warningTypesForRuleAndSourceDomain(abstract->id(), _parent->source()->domain().name()); //If there is a warning to display, change the border's color if(_warning_type!=InvalidType) { //Create the border if it didn't exist if(_border==0) { QPainterPathStroker stroker; stroker.setWidth(3); _border=new QGraphicsPathItem(stroker.createStroke(shape()), this, scene()); _border->setPen(QPen(QBrush(), 0, Qt::NoPen)); _border->setFlag(ItemStacksBehindParent, true); } ArrowColorAnimation &anim=ArrowColorAnimation::instance(); _border->setBrush(anim.getColorFromRuleWarningType(_parent->warningType())); _border->setGraphicsEffect(new QGraphicsBlurEffect()); } } //Hide the rule if necessary if(_hidden ^ stack.isRuleHidden(abstract->id())) setHiddenByUser(allRulesHidden() || stack.isProgramHidden(_app_name)); }
QPainterPath QgsLayoutItemPolyline::shape() const { QPainterPath path; path.addPolygon( mPolygon ); QPainterPathStroker ps; ps.setWidth( 2 * mMaxSymbolBleed ); QPainterPath strokedOutline = ps.createStroke( path ); return strokedOutline; }