/**
* \brief Draw the palette
* @param event as the paint event
*/
void UBDockPalette::paintEvent(QPaintEvent *event)
{
Q_UNUSED(event);
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing);
painter.setPen(Qt::NoPen);
painter.setBrush(mBackgroundBrush);
if(mOrientation == eUBDockOrientation_Left)
{
QPainterPath path;
path.setFillRule(Qt::WindingFill);
path.addRect(0.0, 0.0, width()-border(), height());
path.addRoundedRect(width()-2*border(), border(), 2*border(), TABSIZE, radius(), radius());
painter.drawPath(path);
painter.drawPixmap(width() - border() + 1, border() + 1 , border() - 4, TABSIZE - 2, mIcon);
}
else if(mOrientation == eUBDockOrientation_Right)
{
QPainterPath path;
path.setFillRule(Qt::WindingFill);
path.addRect(border(), 0.0, width()-border(), height());
path.addRoundedRect(0.0, border(), 2*border(), TABSIZE, radius(), radius());
painter.drawPath(path);
painter.drawPixmap(2, border() + 1, border() - 3, TABSIZE - 2, mIcon);
}
else
{
painter.drawRoundedRect(border(), border(), width() - 2 * border(), height() - 2 * border(), radius(), radius());
}
}
void DropShadowWidget::paintEvent(QPaintEvent *event)
{
int margins = 10;
if(this->isMaximized()){
margins = 0;
}
QPainterPath path;
path.setFillRule(Qt::WindingFill);
path.addRect(margins, margins, this->width()-2*margins, this->height()-2*margins);
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing, true);
painter.fillPath(path, QBrush(Qt::white));
QColor color(0, 0, 0, 50);
for(int i=0; i<margins; i++)
{
QPainterPath path;
path.setFillRule(Qt::WindingFill);
path.addRect(margins-i, margins-i, this->width()-(margins-i)*2, this->height()-(margins-i)*2);
color.setAlpha(150 - qSqrt(i)*50);
painter.setPen(color);
painter.drawPath(path);
}
}
void tst_QPainterPath::arcWinding_data()
{
QTest::addColumn<QPainterPath>("path");
QTest::addColumn<QPointF>("point");
QTest::addColumn<bool>("inside");
QPainterPath a;
a.addEllipse(0, 0, 100, 100);
a.addRect(50, 50, 100, 100);
QTest::newRow("Case A (oddeven)") << a << QPointF(55, 55) << false;
a.setFillRule(Qt::WindingFill);
QTest::newRow("Case A (winding)") << a << QPointF(55, 55) << true;
QPainterPath b;
b.arcMoveTo(0, 0, 100, 100, 10);
b.arcTo(0, 0, 100, 100, 10, 360);
b.addRect(50, 50, 100, 100);
QTest::newRow("Case B (oddeven)") << b << QPointF(55, 55) << false;
b.setFillRule(Qt::WindingFill);
QTest::newRow("Case B (winding)") << b << QPointF(55, 55) << false;
QPainterPath c;
c.arcMoveTo(0, 0, 100, 100, 0);
c.arcTo(0, 0, 100, 100, 0, 360);
c.addRect(50, 50, 100, 100);
QTest::newRow("Case C (oddeven)") << c << QPointF(55, 55) << false;
c.setFillRule(Qt::WindingFill);
QTest::newRow("Case C (winding)") << c << QPointF(55, 55) << false;
QPainterPath d;
d.arcMoveTo(0, 0, 100, 100, 10);
d.arcTo(0, 0, 100, 100, 10, -360);
d.addRect(50, 50, 100, 100);
QTest::newRow("Case D (oddeven)") << d << QPointF(55, 55) << false;
d.setFillRule(Qt::WindingFill);
QTest::newRow("Case D (winding)") << d << QPointF(55, 55) << true;
QPainterPath e;
e.arcMoveTo(0, 0, 100, 100, 0);
e.arcTo(0, 0, 100, 100, 0, -360);
e.addRect(50, 50, 100, 100);
QTest::newRow("Case E (oddeven)") << e << QPointF(55, 55) << false;
e.setFillRule(Qt::WindingFill);
QTest::newRow("Case E (winding)") << e << QPointF(55, 55) << true;
}
QGIFace* QGIViewPart::drawFace(TechDrawGeometry::Face* f, int idx)
{
std::vector<TechDrawGeometry::Wire *> fWires = f->wires;
QPainterPath facePath;
for(std::vector<TechDrawGeometry::Wire *>::iterator wire = fWires.begin(); wire != fWires.end(); ++wire) {
QPainterPath wirePath;
for(std::vector<TechDrawGeometry::BaseGeom *>::iterator edge = (*wire)->geoms.begin(); edge != (*wire)->geoms.end(); ++edge) {
//Save the start Position
QPainterPath edgePath = drawPainterPath(*edge);
// If the current end point matches the shape end point the new edge path needs reversing
QPointF shapePos = (wirePath.currentPosition()- edgePath.currentPosition());
if(sqrt(shapePos.x() * shapePos.x() + shapePos.y()*shapePos.y()) < 0.05) { //magic tolerance
edgePath = edgePath.toReversed();
}
wirePath.connectPath(edgePath);
}
//dumpPath("wirePath:",wirePath);
facePath.addPath(wirePath);
}
facePath.setFillRule(Qt::OddEvenFill);
QGIFace* gFace = new QGIFace(idx);
addToGroup(gFace);
gFace->setPos(0.0,0.0);
gFace->setPath(facePath);
//debug a path
//std::stringstream faceId;
//faceId << "facePath " << idx;
//dumpPath(faceId.str().c_str(),facePath);
return gFace;
}
void UBGraphicsCache::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
Q_UNUSED(option);
Q_UNUSED(widget);
painter->setBrush(mMaskColor);
painter->setPen(mMaskColor);
// Draw the hole
QPainterPath path;
path.addRect(rect());
if(mDrawMask)
{
if(eMaskShape_Circle == mMaskShape)
{
path.addEllipse(mShapePos, mShapeWidth, mShapeWidth);
}
else if(eMaskShap_Rectangle == mMaskShape)
{
path.addRect(mShapePos.x() - mShapeWidth, mShapePos.y() - mShapeWidth, 2*mShapeWidth, 2*mShapeWidth);
}
path.setFillRule(Qt::OddEvenFill);
}
painter->drawPath(path);
}
void QRoundProgressBar::drawValue(QPainter &p, const QRectF &baseRect, double value, double arcLength)
{
// nothing to draw
if (value == m_min)
return;
// for Line style
if (m_barStyle == StyleLine)
{
p.setPen(QPen(palette().highlight().color(), m_dataPenWidth));
p.setBrush(Qt::NoBrush);
p.drawArc(baseRect.adjusted(m_outlinePenWidth/2, m_outlinePenWidth/2, -m_outlinePenWidth/2, -m_outlinePenWidth/2),
m_nullPosition * 16,
-arcLength * 16);
return;
}
// for Pie and Donut styles
QPainterPath dataPath;
dataPath.setFillRule(Qt::WindingFill);
// pie segment outer
dataPath.moveTo(baseRect.center());
dataPath.arcTo(baseRect, m_nullPosition, -arcLength);
dataPath.lineTo(baseRect.center());
p.setBrush(palette().highlight());
p.setPen(QPen(palette().shadow().color(), m_dataPenWidth));
p.drawPath(dataPath);
}
QPainterPath BI_Via::toQPainterPathPx(const Length& expansion) const noexcept {
QPainterPath p = getOutline(expansion).toQPainterPathPx();
p.setFillRule(Qt::OddEvenFill); // important to subtract the hole!
p.addEllipse(QPointF(0, 0), mDrillDiameter->toPx() / 2,
mDrillDiameter->toPx() / 2);
return p;
}
void tst_QPainterPath::intersects_QRectF_data()
{
QTest::addColumn<QPainterPath>("path");
QTest::addColumn<QRectF>("rect");
QTest::addColumn<bool>("intersects");
QPainterPath path;
path.addRect(0, 0, 100, 100);
QTest::newRow("same rect") << path << QRectF(0.1, 0.1, 99, 99) << true; // ###
QTest::newRow("outside") << path << QRectF(-1, -1, 100, 100) << true;
QTest::newRow("covers") << path << QRectF(-1, -1, 102, 102) << true;
QTest::newRow("left") << path << QRectF(-10, 50, 5, 5) << false;
QTest::newRow("top") << path << QRectF(50, -10, 5, 5) << false;
QTest::newRow("right") << path << QRectF(110, 50, 5, 5) << false;
QTest::newRow("bottom") << path << QRectF(50, 110, 5, 5) << false;
path.addRect(50, 50, 100, 100);
QTest::newRow("r1 top") << path << QRectF(0.1, 0.1, 99, 49) << true;
QTest::newRow("r1 left") << path << QRectF(0.1, 0.1, 49, 99) << true;
QTest::newRow("r2 right") << path << QRectF(100.01, 50.1, 49, 99) << true;
QTest::newRow("r2 bottom") << path << QRectF(50.1, 100.1, 99, 49) << true;
QTest::newRow("inside 2 rects") << path << QRectF(51, 51, 48, 48) << false;
path.setFillRule(Qt::WindingFill);
QTest::newRow("inside 2 rects (winding)") << path << QRectF(51, 51, 48, 48) << true;
path.addEllipse(0, 0, 150, 150);
QTest::newRow("topRight 2 rects") << path << QRectF(100, 25, 24, 24) << true;
QTest::newRow("bottomLeft 2 rects") << path << QRectF(25, 100, 24, 24) << true;
QTest::newRow("horizontal line") << linePath(0, 0, 10, 0) << QRectF(1, -1, 2, 2) << true;
QTest::newRow("vertical line") << linePath(0, 0, 0, 10) << QRectF(-1, 1, 2, 2) << true;
}
/**
* @brief RefreshGeometry refresh item on scene.
*/
void VToolSpline::RefreshGeometry()
{
this->setPen(QPen(currentColor, qApp->toPixel(qApp->widthHairLine())/factor));
const VSpline *spl = VAbstractTool::data.GeometricObject<const VSpline *>(id);
QPainterPath path;
path.addPath(spl->GetPath());
path.setFillRule( Qt::WindingFill );
this->setPath(path);
QPointF splinePoint = VAbstractTool::data.GeometricObject<const VPointF *>(spl->GetP1().id())->toQPointF();
QPointF controlPoint = spl->GetP2();
emit RefreshLine(1, SplinePointPosition::FirstPoint, controlPoint, splinePoint);
splinePoint = VAbstractTool::data.GeometricObject<const VPointF *>(spl->GetP4().id())->toQPointF();
controlPoint = spl->GetP3();
emit RefreshLine(1, SplinePointPosition::LastPoint, controlPoint, splinePoint);
disconnect(controlPoints[0], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSpline::ControlPointChangePosition);
disconnect(controlPoints[1], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSpline::ControlPointChangePosition);
controlPoints[0]->setPos(spl->GetP2());
controlPoints[1]->setPos(spl->GetP3());
connect(controlPoints[0], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSpline::ControlPointChangePosition);
connect(controlPoints[1], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSpline::ControlPointChangePosition);
}
void TClickableLabel::paintEvent(QPaintEvent *e)
{
QPainter painter(this);
if (m_isEnter) {
painter.save();
QRect r = rect();
double h = r.height();
double h2 = r.height() / 2.0;
QPainterPath path;
path.addRect(r.x() + h2, r.y() + 0, r.width() - h2 * 2, r.height());
path.addEllipse(r.x(), r.y(), h, h);
path.addEllipse(r.x() + r.width() - h, r.y(), h, h);
path.setFillRule(Qt::WindingFill);
painter.setPen(Qt::NoPen);
painter.setBrush( palette().brush(QPalette::Highlight) );
painter.setRenderHint(QPainter::Antialiasing);
painter.drawPath(path);
painter.restore();
}
QRect r = rect();
r.setX((int) (r.x() + m_text->textWidth())/2);
m_text->drawContents(&painter, r);
painter.end();
QWidget::paintEvent(e);
}
/**
* \brief Draw the palette
* @param event as the paint event
*/
void UBDockPalette::paintEvent(QPaintEvent *event)
{
Q_UNUSED(event);
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing);
painter.setPen(Qt::NoPen);
painter.setBrush(mBackgroundBrush);
QPainterPath path;
path.setFillRule(Qt::WindingFill);
int nbTabs = mTabWidgets.size();
if(0 < nbTabs)
{
// First draw the BIG RECTANGLE (I write it big because the rectangle is big...)
if(mOrientation == eUBDockOrientation_Left)
{
path.addRect(0.0, 0.0, width(), height());
}
else if(mOrientation == eUBDockOrientation_Right)
{
path.addRect(0.0, 0.0, width(), height());
}
painter.drawPath(path);
}
}
QPainterPath IsometricRenderer::shape(const MapObject *object) const
{
QPainterPath path;
if (!object->cell().isEmpty()) {
path.addRect(boundingRect(object));
} else {
switch (object->shape()) {
case MapObject::Ellipse:
case MapObject::Rectangle:
path.addPolygon(pixelRectToScreenPolygon(object->bounds()));
break;
case MapObject::Polygon:
case MapObject::Polyline: {
const QPointF &pos = object->position();
const QPolygonF polygon = object->polygon().translated(pos);
const QPolygonF screenPolygon = pixelToScreenCoords(polygon);
if (object->shape() == MapObject::Polygon) {
path.addPolygon(screenPolygon);
} else {
for (int i = 1; i < screenPolygon.size(); ++i) {
path.addPolygon(lineToPolygon(screenPolygon[i - 1],
screenPolygon[i]));
}
path.setFillRule(Qt::WindingFill);
}
break;
}
}
}
return path;
}
void ZLabel::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) {
QPainterPath path;
path.setFillRule(Qt::WindingFill);
path.moveTo(m_BRect.x(), m_BRect.y());
path.lineTo(m_BRect.x()+m_BRect.width()/2, m_BRect.y());
QRectF rect = m_BRect;
rect.setX(rect.x()+rect.width()/2);
path.arcTo(rect, 90, -180);
path.lineTo(m_BRect.x(), m_BRect.y()+m_BRect.height());
painter->setPen(QPen(Qt::black, 0) );
painter->drawPath(path);
if(option->state & QStyle::State_Selected) {
painter->setPen(Qt::NoPen);
QColor lightGray(192, 192, 192, 128);
painter->setBrush(lightGray);
painter->drawPath(path);
}
else {
painter->setPen(Qt::NoPen);
QColor lightGray(128, 128, 128, 128);
painter->setBrush(lightGray);
painter->drawPath(path);
}
QFont font; font.setPixelSize(18);
painter->setPen(QPen(Qt::black, 0));
painter->setFont(font);
painter->drawText(m_BRect, Qt::AlignCenter, QString::number(m_iZLayer) );
}
QPainterPath
rce::gui::RGraphicsFlagItem::
generateFlagPath(const QRectF &flagArea)
{
QPainterPath path;
path.setFillRule(Qt::WindingFill);
path.moveTo(0,0);
if((flagArea.width() > 0) &&
(flagArea.height() > 0))
{
QRectF adjustedArea = flagArea.adjusted(-RCE_EMPHASED_LINE_WIDTH,
-RCE_EMPHASED_LINE_WIDTH,
RCE_EMPHASED_LINE_WIDTH,
RCE_EMPHASED_LINE_WIDTH); // TODO: Make this automaticly scale with font size
path.lineTo(adjustedArea.bottomLeft());
path.addRect(adjustedArea);
}
path.moveTo(0,0);
path.addEllipse(QPointF(0,0),
1.0, 1.0);
return path;
}
QPainterPath TextSymbol::painterPath(void)
{
QPainterPath path;
path.setFillRule(Qt::WindingFill);
QString filename = ctx.loader->absPath("fonts/" + m_font);
FontDataStore* ds = CachedFontParser::parse(filename);
QMatrix mat(m_xsize / ds->xsize(), 0, 0, m_ysize / ds->ysize(), 0, 0);
for (int i = 0; i < m_text.length(); ++i) {
CharRecord* rec = ds->charRecord(m_text[i].toAscii());
if (rec) {
QPainterPath p = mat.map(rec->painterPath(m_width_factor));
path.addPath(p);
}
mat.translate(ds->xsize() + ds->offset(), 0);
}
QRectF b = path.boundingRect();
QMatrix mat2;
mat2.translate(-b.x(), -(b.y() + b.height()));
path = mat2.map(path);
return path;
}
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 tst_QPainterPath::testOperatorDatastream()
{
QPainterPath path;
path.addEllipse(0, 0, 100, 100);
path.addRect(0, 0, 100, 100);
path.setFillRule(Qt::WindingFill);
// Write out
{
QFile data("data");
bool ok = data.open(QFile::WriteOnly);
QVERIFY(ok);
QDataStream stream(&data);
stream << path;
}
QPainterPath other;
// Read in
{
QFile data("data");
bool ok = data.open(QFile::ReadOnly);
QVERIFY(ok);
QDataStream stream(&data);
stream >> other;
}
QVERIFY(other == path);
}
/**
* \brief Draw the palette
* @param event as the paint event
*/
void UBDockPalette::paintEvent(QPaintEvent *event)
{
Q_UNUSED(event);
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing);
painter.setPen(Qt::NoPen);
painter.setBrush(mBackgroundBrush);
QPainterPath path;
path.setFillRule(Qt::WindingFill);
int nbTabs = mTabWidgets.size();
if(0 < nbTabs)
{
// First draw the BIG RECTANGLE (I write it big because the rectangle is big...)
if(mOrientation == eUBDockOrientation_Left)
{
path.addRect(0.0, 0.0, width(), height());
}
else if(mOrientation == eUBDockOrientation_Right)
{
path.addRect(0.0, 0.0, width(), height());
}
// THEN DRAW THE small tabs (yes, the tabs are small...)
if(eUBDockTabOrientation_Up == mTabsOrientation)
{
mHTab = border();
}
else
{
mHTab = height() - border() - nbTabs*TABSIZE - (nbTabs-1)*tabSpacing();
}
painter.drawPath(path);
}
}
void CustomFrame::paintEvent(QPaintEvent *e)
{
int border = FRAME_BORDER;
if (this->isMaximized()) {
border = 0;
}
QPainter painter(this);
QPainterPath painterPath;
painterPath.setFillRule(Qt::WindingFill);
painterPath.addRect(border, border, this->width()-2*border, this->height()-2*border);
painter.setRenderHint(QPainter::Antialiasing, true);
painter.fillPath(painterPath, QBrush(Qt::white));
QColor color(200, 200, 200);
for (int i=0; i<border; i++) {
color.setAlpha((i+1)*30);
painter.setPen(color);
painter.drawRect(border-i, border-i, this->width()-(border-i)*2, this->height()-(border-i)*2);
}
painter.setPen(Qt::NoPen);
painter.setBrush(Qt::white);
// 这里可以在资源中指定一张标题背景图片
//painter.drawPixmap(QRect(border, border, this->width()-2*border, this->height()-2*border), QPixmap(DEFAULT_SKIN));
painter.drawRect(QRect(border, TITLE_HEIGHT, this->width()-2*border, this->height()-TITLE_HEIGHT-border));
QFrame::paintEvent(e);
}
static QPainterPath qwtTransformPath( const QwtScaleMap &xMap,
const QwtScaleMap &yMap, const QPainterPath &path, bool doAlign )
{
QPainterPath shape;
shape.setFillRule( path.fillRule() );
for ( int i = 0; i < path.elementCount(); i++ )
{
const QPainterPath::Element &element = path.elementAt( i );
double x = xMap.transform( element.x );
double y = yMap.transform( element.y );
switch( element.type )
{
case QPainterPath::MoveToElement:
{
if ( doAlign )
{
x = qRound( x );
y = qRound( y );
}
shape.moveTo( x, y );
break;
}
case QPainterPath::LineToElement:
{
if ( doAlign )
{
x = qRound( x );
y = qRound( y );
}
shape.lineTo( x, y );
break;
}
case QPainterPath::CurveToElement:
{
const QPainterPath::Element& element1 = path.elementAt( ++i );
const double x1 = xMap.transform( element1.x );
const double y1 = yMap.transform( element1.y );
const QPainterPath::Element& element2 = path.elementAt( ++i );
const double x2 = xMap.transform( element2.x );
const double y2 = yMap.transform( element2.y );
shape.cubicTo( x, y, x1, y1, x2, y2 );
break;
}
case QPainterPath::CurveToDataElement:
{
break;
}
}
}
return shape;
}
QPainterPath Paths::windingFill()
{
QPainterPath path;
path.addRect(0, 0, 100, 100);
path.addRect(50, 25, 100, 50);
path.setFillRule(Qt::WindingFill);
return path;
}
void Window::setupShapes()
{
QPainterPath truck;
truck.setFillRule(Qt::WindingFill);
truck.moveTo(0.0, 87.0);
truck.lineTo(0.0, 60.0);
truck.lineTo(10.0, 60.0);
truck.lineTo(35.0, 35.0);
truck.lineTo(100.0, 35.0);
truck.lineTo(100.0, 87.0);
truck.lineTo(0.0, 87.0);
truck.moveTo(17.0, 60.0);
truck.lineTo(55.0, 60.0);
truck.lineTo(55.0, 40.0);
truck.lineTo(37.0, 40.0);
truck.lineTo(17.0, 60.0);
truck.addEllipse(17.0, 75.0, 25.0, 25.0);
truck.addEllipse(63.0, 75.0, 25.0, 25.0);
QPainterPath clock;
clock.addEllipse(-50.0, -50.0, 100.0, 100.0);
clock.addEllipse(-48.0, -48.0, 96.0, 96.0);
clock.moveTo(0.0, 0.0);
clock.lineTo(-2.0, -2.0);
clock.lineTo(0.0, -42.0);
clock.lineTo(2.0, -2.0);
clock.lineTo(0.0, 0.0);
clock.moveTo(0.0, 0.0);
clock.lineTo(2.732, -0.732);
clock.lineTo(24.495, 14.142);
clock.lineTo(0.732, 2.732);
clock.lineTo(0.0, 0.0);
QPainterPath house;
house.moveTo(-45.0, -20.0);
house.lineTo(0.0, -45.0);
house.lineTo(45.0, -20.0);
house.lineTo(45.0, 45.0);
house.lineTo(-45.0, 45.0);
house.lineTo(-45.0, -20.0);
house.addRect(15.0, 5.0, 20.0, 35.0);
house.addRect(-35.0, -15.0, 25.0, 25.0);
QPainterPath text;
QFont font;
font.setPixelSize(50);
QRect fontBoundingRect = QFontMetrics(font).boundingRect(tr("Qt"));
text.addText(-QPointF(fontBoundingRect.center()), font, tr("Qt"));
shapes.append(clock);
shapes.append(house);
shapes.append(text);
shapes.append(truck);
connect(shapeComboBox, SIGNAL(activated(int)), this, SLOT(shapeSelected(int)));
}
QPainterPath shape() const override
{
QPainterPath path;
path.setFillRule(Qt::WindingFill);
if (m_arrowItem)
path.addRect(mapRectFromItem(m_arrowItem, m_arrowItem->boundingRect()));
if (m_diamondItem)
path.addRect(mapRectFromItem(m_diamondItem, m_diamondItem->boundingRect()));
return path;
}
void GraphicsContext::clipPath(WindRule clipRule)
{
if (paintingDisabled())
return;
QPainter *p = m_data->p();
QPainterPath newPath = m_data->currentPath;
newPath.setFillRule(clipRule == RULE_EVENODD ? Qt::OddEvenFill : Qt::WindingFill);
p->setClipPath(newPath);
}
//------------------------------------------------------------------------------
void
Canvas::DrawFilledRectangle(int left, int top, int right, int bottom,
const Color color)
{
QPainterPath path;
path.setFillRule(Qt::WindingFill);
path.addRect(left, top, right - left, bottom - top);
Brush a_brush(color);
this->pushObject(path, this->pen(), a_brush());
}
void DropShadowWidget::paintEvent(QPaintEvent *event)
{
QPainterPath path;
path.setFillRule(Qt::WindingFill);
path.addRect(10,10,this->width()-20,this->height()-20);
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing, true);
painter.fillPath(path, QBrush(Qt::red));
QColor color(0,0,0,50);
for(int i=0; i<10; ++i){
QPainterPath path;
path.setFillRule(Qt::WindingFill);
path.addRect(10-i, 10-i, this->width()-(10-i)*2, this->height()-(10-i)*2);
color.setAlpha(150-qSqrt(i)*50);
painter.setPen(color);
painter.drawPath(path);
}
}
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;
}
QPainterPath OrthogonalRenderer::shape(const MapObject *object) const
{
QPainterPath path;
if (!object->cell().isEmpty()) {
path.addRect(boundingRect(object));
} else {
switch (object->shape()) {
case MapObject::Rectangle: {
const QRectF bounds = object->bounds();
const QRectF rect(tileToPixelCoords(bounds.topLeft()),
tileToPixelCoords(bounds.bottomRight()));
if (rect.isNull()) {
path.addEllipse(rect.topLeft(), 20, 20);
} else {
path.addRoundedRect(rect, 10, 10);
}
break;
}
case MapObject::Polygon:
case MapObject::Polyline: {
const QPointF &pos = object->position();
const QPolygonF polygon = object->polygon().translated(pos);
const QPolygonF screenPolygon = tileToPixelCoords(polygon);
if (object->shape() == MapObject::Polygon) {
path.addPolygon(screenPolygon);
} else {
for (int i = 1; i < screenPolygon.size(); ++i) {
path.addPolygon(lineToPolygon(screenPolygon[i - 1],
screenPolygon[i]));
}
path.setFillRule(Qt::WindingFill);
}
break;
}
case MapObject::Ellipse: {
const QRectF bounds = object->bounds();
const QRectF rect(tileToPixelCoords(bounds.topLeft()),
tileToPixelCoords(bounds.bottomRight()));
if (rect.isNull()) {
path.addEllipse(rect.topLeft(), 20, 20);
} else {
path.addEllipse(rect);
}
break;
}
}
}
return path;
}
QPainterPath ArrowItem::shape() const {
QPainterPath selectPath;
selectPath.setFillRule(Qt::WindingFill);
selectPath.addPolygon(rect());
selectPath.addPolygon(start);
selectPath.addPolygon(end);
if ((!isSelected() && !isHovering()) || (view()->mouseMode() == View::Create)) {
} else {
selectPath.addPath(grips());
}
return selectPath;
}
void MusicRemoteWidgetForCircle::paintEvent(QPaintEvent* event)
{
MusicRemoteWidget::paintEvent(event);
QPainter painter(this);
painter.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
QPainterPath path;
path.addEllipse(15, 15, 135, 135);
path.addEllipse(32, 32, 100, 100);
path.setFillRule(Qt::OddEvenFill);
painter.fillPath(path, QBrush(QColor(0, 0, 0, 50)));
painter.end();
}
