void Tab::paintEvent(QPaintEvent *event) { Q_UNUSED(event) QPainter painter(this); painter.setRenderHint(QPainter::Antialiasing); QBrush brush; brush.setStyle(Qt::SolidPattern); brush.setColor(backgroundColor()); painter.setOpacity(1); painter.setBrush(brush); painter.setPen(Qt::NoPen); painter.drawRect(rect()); paintHalo(&painter); QStylePainter style(this); if (!icon().isNull()) { style.translate(0, 12); } QStyleOptionButton option; initStyleOption(&option); option.features |= QStyleOptionButton::Flat; option.iconSize = QSize(-1, -1); // Prevent icon from being drawn twice style.drawControl(QStyle::CE_PushButtonLabel, option); if (!icon().isNull()) { const QSize &size = iconSize(); QRect iconRect(QPoint((width()-size.width())/2, 0), size); icon().paint(&painter, iconRect, Qt::AlignCenter, QIcon::Normal); } if (!_active) { QColor overlayColor = backgroundColor(); overlayColor.setAlphaF(0.36); QBrush overlay; overlay.setStyle(Qt::SolidPattern); overlay.setColor(overlayColor); painter.fillRect(rect(), overlay); } #ifdef DEBUG_LAYOUT QPainter debug(this); QPen pen; pen.setColor(Qt::red); pen.setWidth(2); debug.setPen(pen); debug.setBrush(Qt::NoBrush); debug.drawRect(rect()); #endif }
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) { // ----------------------------------------------------------------------- ui->setupUi(this); QGraphicsScene *scene = new QGraphicsScene(this); ui->graphicsView->setScene(scene); // ----------------------------------------------------------------------- // kolor pedzla QBrush brush = QBrush(Qt::red); brush.setStyle(Qt::DiagCrossPattern); // tworzymy obiekts QGraphicsRectItem *rect = new QGraphicsRectItem(10, 10, 90, 90); rect->setBrush(brush); // ----------------------------------------------------------------------- // ----------------------------------------------------------------------- // definiujemy czas trwania animacji QTimeLine *timeLine = new QTimeLine(1000); timeLine->setFrameRange(0, 100); // definiujemy animacje QGraphicsItemAnimation *animation = new QGraphicsItemAnimation(); animation->setItem(rect); animation->setTimeLine(timeLine); // animacja int odcinek = 100; for (int i = 0; i < 100; ++i) animation->setPosAt(i / 100.0, QPointF(i, i)); // uruchamiamy scenę i animację scene->addItem(rect); timeLine->start(); }
void Hex::setOwner(QString player){ // set the owner owner = player; // change the color if (player == QString("NOONE")){ QBrush brush; brush.setStyle(Qt::SolidPattern); brush.setColor(Qt::lightGray); setBrush(brush); } if (player == QString("PLAYER1")){ QBrush brush; brush.setStyle(Qt::SolidPattern); brush.setColor(Qt::blue); setBrush(brush); } if (player == QString("PLAYER2")){ QBrush brush; brush.setStyle(Qt::SolidPattern); brush.setColor(Qt::red); setBrush(brush); } }
void QtArrowItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *) { painter->setRenderHint(QPainter::Antialiasing); if (this->isSelected()) { const QColor color(255,0,0); QPen pen; pen.setColor(color); pen.setWidth(3); painter->setPen(pen); QBrush brush; brush.setColor(color); brush.setStyle(Qt::SolidPattern); painter->setBrush(brush); } else { const QColor color(0,0,0); QPen pen; pen.setColor(color); pen.setWidth(1); painter->setPen(pen); QBrush brush; brush.setColor(color); brush.setStyle(Qt::SolidPattern); painter->setBrush(brush); } painter->drawLine(this->line()); //The angle from tail to head double angle = GetAngle(line().dx(),line().dy()); if (line().dy() >= 0.0) angle = (1.0 * M_PI) + angle; const double sz = 10.0; //pixels { const QPointF p0 = this->line().p1(); const QPointF p1 = p0 + QPointF( std::sin(angle + M_PI + (M_PI * 0.1)) * sz, -std::cos(angle + M_PI + (M_PI * 0.1)) * sz); const QPointF p2 = p0 + QPointF( std::sin(angle + M_PI - (M_PI * 0.1)) * sz, -std::cos(angle + M_PI - (M_PI * 0.1)) * sz); painter->drawPolygon(QPolygonF() << p0 << p1 << p2); } { const QPointF p0 = this->line().p2(); const QPointF p1 = p0 + QPointF( std::sin(angle + 0.0 + (M_PI * 0.1)) * sz, -std::cos(angle + 0.0 + (M_PI * 0.1)) * sz); const QPointF p2 = p0 + QPointF( std::sin(angle + 0.0 - (M_PI * 0.1)) * sz, -std::cos(angle + 0.0 - (M_PI * 0.1)) * sz); painter->drawPolygon(QPolygonF() << p0 << p1 << p2); } }
void QgsLayoutItemPolyline::drawArrowHead( QPainter *p, const double x, const double y, const double angle, const double arrowHeadWidth ) { if ( !p ) return; double angleRad = angle / 180.0 * M_PI; QPointF middlePoint( x, y ); //rotate both arrow points QPointF p1 = QPointF( -arrowHeadWidth / 2.0, arrowHeadWidth ); QPointF p2 = QPointF( arrowHeadWidth / 2.0, arrowHeadWidth ); QPointF p1Rotated, p2Rotated; p1Rotated.setX( p1.x() * std::cos( angleRad ) + p1.y() * -std::sin( angleRad ) ); p1Rotated.setY( p1.x() * std::sin( angleRad ) + p1.y() * std::cos( angleRad ) ); p2Rotated.setX( p2.x() * std::cos( angleRad ) + p2.y() * -std::sin( angleRad ) ); p2Rotated.setY( p2.x() * std::sin( angleRad ) + p2.y() * std::cos( angleRad ) ); QPolygonF arrowHeadPoly; arrowHeadPoly << middlePoint; arrowHeadPoly << QPointF( middlePoint.x() + p1Rotated.x(), middlePoint.y() + p1Rotated.y() ); arrowHeadPoly << QPointF( middlePoint.x() + p2Rotated.x(), middlePoint.y() + p2Rotated.y() ); QPen arrowPen = p->pen(); arrowPen.setJoinStyle( Qt::RoundJoin ); QBrush arrowBrush = p->brush(); arrowBrush.setStyle( Qt::SolidPattern ); p->setPen( arrowPen ); p->setBrush( arrowBrush ); arrowBrush.setStyle( Qt::SolidPattern ); p->drawPolygon( arrowHeadPoly ); }
QBrush FillTab::brush(QBrush b) const { QColor this_color = colorDirty() ? color() : b.color(); Qt::BrushStyle this_style = styleDirty() ? style() : b.style(); if (useGradientDirty()) { // Apply / unapply gradient if (useGradient()) { b = QBrush(gradient()); } else { b.setColor(this_color); b.setStyle(this_style); } } else { // Leave gradient but make other changes. QGradient this_gradient; if (const QGradient *grad = b.gradient()) { if (gradientDirty()) { this_gradient = gradient(); } else { this_gradient = *grad; } b = QBrush(this_gradient); } else { b.setColor(this_color); b.setStyle(this_style); } } return b; }
void KnotRendererBatch::PaintInterfaceData::set(int fillColour, int outlineColour, int outlineWidth, const QList< QColor > colorList) { QPen pen = p->pen(); pen.setWidth(outlineWidth); if (outlineColour != -1) pen.setColor(colorList[outlineColour]); else { QBrush brush = pen.brush(); brush.setStyle(Qt::NoBrush); pen.setBrush(brush); } p->setPen(pen); QBrush brush = p->brush(); if (fillColour == -1) { brush.setStyle(Qt::NoBrush); } else { brush.setStyle(Qt::SolidPattern); brush.setColor(colorList[fillColour]); } p->setBrush(brush); }
void VpGrid::drawReference(GridGC &gridGC) { int x,y; VpGC *vpgc = gridGC.m_gc; QPainter *gc = vpgc->getGC(); // Assuming QPainter has already established begin(). gc->setRenderHint(QPainter::Antialiasing, true); if (m_referenceStyle == VpGrid::REFSTYLE_SQUARE) { // Set the pen. QPen pen; pen.setStyle(Qt::NoPen); gc->setPen(pen); // Set the brush. QBrush brush; brush.setColor(m_referenceColor); brush.setStyle(Qt::SolidPattern); gc->setBrush(brush); QRectF origin; origin.setLeft(-1.5 + m_xAlignment); origin.setRight(1.5 + m_xAlignment); origin.setBottom(-1.5 + m_yAlignment); origin.setTop(1.5 + m_yAlignment); gc->drawRect(origin); } else if (m_referenceStyle == VpGrid::REFSTYLE_CIRCLE) { // Set the pen. QPen pen; pen.setStyle(Qt::NoPen); gc->setPen(pen); // Set the brush. QBrush brush; brush.setColor(m_referenceColor); brush.setStyle(Qt::SolidPattern); gc->setBrush(brush); gc->drawEllipse(QPoint(m_xAlignment, m_yAlignment), 2, 2); } else { // Set the pen, no brush. QPen pen; pen.setColor(m_referenceColor); pen.setStyle(Qt::SolidLine); pen.setWidth(2); gc->setPen(pen); // Create a 'X' pattern. QLineF cross[2]; cross[0].setLine(-1.5 + m_xAlignment, -1.5 + m_yAlignment, 1.5 + m_xAlignment, 1.5 + m_yAlignment); cross[1].setLine(-1.5 + m_xAlignment, 1.5 + m_yAlignment, 1.5 + m_xAlignment, -1.5 + m_yAlignment); gc->drawLines(cross, 2); } //delete gc; }
void KoSectionStyle::loadOdf(const KoXmlElement *element, KoOdfLoadingContext &context) { if (element->hasAttributeNS(KoXmlNS::style, "display-name")) d->name = element->attributeNS(KoXmlNS::style, "display-name", QString()); if (d->name.isEmpty()) // if no style:display-name is given us the style:name d->name = element->attributeNS(KoXmlNS::style, "name", QString()); context.styleStack().save(); // Load all parents - only because we don't support inheritance. QString family = element->attributeNS(KoXmlNS::style, "family", "section"); context.addStyles(element, family.toLocal8Bit().constData()); // Load all parents - only because we don't support inheritance. context.styleStack().setTypeProperties("section"); // load all style attributes from "style:section-properties" KoStyleStack &styleStack = context.styleStack(); // in 1.6 this was defined at KoParagLayout::loadOasisParagLayout(KoParagLayout&, KoOasisContext&) if (styleStack.hasProperty(KoXmlNS::style, "writing-mode")) { // http://www.w3.org/TR/2004/WD-xsl11-20041216/#writing-mode QString writingMode = styleStack.property(KoXmlNS::style, "writing-mode"); setTextProgressionDirection(KoText::directionFromString(writingMode)); } // Indentation (margin) bool hasMarginLeft = styleStack.hasProperty(KoXmlNS::fo, "margin-left"); bool hasMarginRight = styleStack.hasProperty(KoXmlNS::fo, "margin-right"); if (hasMarginLeft) setLeftMargin(KoUnit::parseValue(styleStack.property(KoXmlNS::fo, "margin-left"))); if (hasMarginRight) setRightMargin(KoUnit::parseValue(styleStack.property(KoXmlNS::fo, "margin-right"))); // The fo:background-color attribute specifies the background color of a paragraph. if (styleStack.hasProperty(KoXmlNS::fo, "background-color")) { const QString bgcolor = styleStack.property(KoXmlNS::fo, "background-color"); QBrush brush = background(); if (bgcolor == "transparent") brush.setStyle(Qt::NoBrush); else { if (brush.style() == Qt::NoBrush) brush.setStyle(Qt::SolidPattern); brush.setColor(bgcolor); // #rrggbb format } setBackground(brush); } styleStack.restore(); }
void Button::hoverLeaveEvent(QGraphicsSceneHoverEvent *event) { // change color to dark cyan QBrush brush; brush.setStyle(Qt::SolidPattern); brush.setColor(Qt::darkCyan); setBrush(brush); }
void AssetDecodePopup::paintEvent(QPaintEvent *) { QStyleOption opt; opt.init(this); QPainter p(this); //style()->drawPrimitive(QStyle::PE_Widget, &opt, &p, this); itemMutex.lock(); QBrush brush; brush.setColor(QColor(51, 51, 51)); brush.setStyle(Qt::BrushStyle::SolidPattern); p.fillRect(0, 0, width(), height(), brush); QPen pen; pen.setColor(QColor(41, 41, 41)); p.setPen(pen); p.drawRect(0, 0, width()-1, height()-1); int yPos = 2; for (const auto& item : m_items) { drawItem(item.displayFilename, item.status, QRect(2, yPos, width() - 5, SingleItemHeight), item.progress); yPos += SingleItemHeight; } itemMutex.unlock(); }
void pigalePaint::DrawText(QPainter *p,Tpoint &a,tvertex v,int col,int center) // draw text centered at a, with a surrounding rectangle // center=1 center // center=0 horizontal {QString t = getVertexLabel(GCP,v); QPen pn = p->pen();pn.setWidth(1);pn.setColor(color[Black]);p->setPen(pn); QSize size = QFontMetrics(p->font()).size(Qt::AlignCenter,t); double nx = size.width() + 4; double ny = size.height(); if(t.length() == 0)nx = ny= 8; QRect rect; //if pn.setWidth() > 1 => rect increase if(center) rect = QRect((int)(to_x(a.x())-nx/2+.5),(int)(to_y(a.y())-ny/2+.5),(int)(nx+.5),(int)(ny+.5)); else rect = QRect((int)(to_x(a.x())-nx/2+.5),(int)(to_y(a.y())-ny+1.),(int)(nx+.5),(int)(ny+.5)); QBrush pb = p->brush(); pb.setStyle(Qt::SolidPattern); pb.setColor(color[bound(col,0,16)]); //pb.setColor(color[White]); p->setBrush(pb); //pn.setColor(color[col]);pn.setWidth(1);p->setPen(pn); pn.setWidth(1);pn.setColor(color[Black]);p->setPen(pn); p->drawRect(rect); if(ny < 6)return; p->drawText(rect,Qt::AlignCenter,t); }
void Draw_Arc::setEdgeRects() { QBrush rectbrush; rectbrush.setColor(QColor(0,175,225)); rectbrush.setStyle(Qt::SolidPattern); qDebug()<<"strt pnt "<<StrtPnt<<" "<<"end pnt "<<EndPnt<<"\n"; Strt_Rect = new QGraphicsRectItem(QRectF(QPointF(StrtPnt.x()-5.0,StrtPnt.y()-5.0),QPointF(StrtPnt.x()+5.0,StrtPnt.y()+5.0))); Strt_Rect->setBrush(rectbrush); End_Rect = new QGraphicsRectItem(QRectF(QPointF(EndPnt.x()-5.0,EndPnt.y()-5.0),QPointF(EndPnt.x()+5.0,EndPnt.y()+5.0))); End_Rect->setBrush(rectbrush); Curve_Rect = new QGraphicsRectItem(QRectF(QPointF(CurvePnt.x()-5.0,CurvePnt.y()-5.0),QPointF(CurvePnt.x()+5.0,CurvePnt.y()+5.0))); Curve_Rect->setBrush(rectbrush); QPen bound_rect; bound_rect.setStyle(Qt::DashLine); Bounding_Rect = new QGraphicsRectItem(QRectF(item->boundingRect().topLeft(),item->boundingRect().bottomRight())); Bounding_Rect->setPen(bound_rect); QPointF pnt1,pnt2; pnt1.setX(((item->boundingRect().topLeft().x()+item->boundingRect().bottomRight().x())/2)-5); pnt1.setY(item->boundingRect().topLeft().y()-20); pnt2.setX(((item->boundingRect().topLeft().x()+item->boundingRect().bottomRight().x())/2)+5); pnt2.setY(item->boundingRect().topLeft().y()-10); Rot_Rect = new QGraphicsEllipseItem(QRectF(pnt1,pnt2)); Rot_Rect->setBrush(rectbrush); }
void CursorRuler::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *) { painter->save(); QBrush brush; int w = width(); int h = height(); brush.setColor(Qt::black); brush.setStyle(Qt::SolidPattern); painter->setPen(Qt::NoPen); painter->setBrush(brush); painter->drawRect(0,0,w,h); int beatLength = 120 / _beatCount; for(int i=0;i<w;i += 120) { painter->setPen(Qt::lightGray); painter->drawLine(i,0,i,h-4); for(int j=1;j<_beatCount;++j) { painter->setPen(Qt::darkGray); painter->drawLine(i+j*beatLength,0,i+j*beatLength,h-8); } } painter->restore(); }
void Dialog::paintEvent(QPaintEvent *e) { QPainter painter(this); // make our polygon QPolygon poly; poly << QPoint(10, 10); poly << QPoint(10, 100); poly << QPoint(100, 10); poly << QPoint(100, 100); // make a pen QPen linePen; linePen.setWidth(8); linePen.setColor(Qt::red); //linePen.setJoinStyle(Qt::RoundJoin); linePen.setJoinStyle(Qt::MiterJoin); linePen.setStyle(Qt::DotLine); painter.setPen(linePen); // make a brush QBrush fillBrush; fillBrush.setColor(Qt::green); fillBrush.setStyle(Qt::SolidPattern); // fill the polygon QPainterPath path; path.addPolygon(poly); painter.fillPath(path, fillBrush); // draw polygon painter.drawPolygon(poly); }
void RSceneDevice::Rect(double x0, double y0, double x1, double y1, R_GE_gcontext *gc) { if (debug) Rprintf("RSceneDevice::Rect\n"); QPen pen(Qt::NoPen); QBrush brush; QRectF rect(x0, y0, x1 - x0, y1 - y0); int col = gc->col; int fill = gc->fill; //double gamma = gc->gamma; double lwd = gc->lwd; int lty = gc->lty; if (col != NA_INTEGER && !R_TRANSPARENT(col)) { pen.setStyle(lty2style(lty)); pen.setColor(r2qColor(col)); pen.setWidthF(lwd); } if (fill != NA_INTEGER && !R_TRANSPARENT(fill)) { brush.setColor(r2qColor(fill)); brush.setStyle(Qt::SolidPattern); } addClippedItem(addRect(rect, pen, brush)); return; }
void GameWindow::drawShip(Ship &ship) { QPainter painter(this); QBrush brush; for(int i=0; i<ship.size; i++) { if( ship.blocks[i] == HEALTHY ) { brush.setColor(Qt::black); brush.setStyle(Qt::SolidPattern); } else if( ship.blocks[i] == KILLED ) { brush.setColor(Qt::red); brush.setStyle(Qt::Dense4Pattern); } painter.setBrush(brush); painter.drawRect( ship.X+i*80, ship.Y+20, 80, 40); } }
void QvkAnimateWindow::paintEvent( QPaintEvent *event ) { (void)event; QPainter painter( this ); painter.setRenderHints( QPainter::Antialiasing, true ); QBrush brush; if ( radiant == false ) { brush.setStyle( Qt::SolidPattern ); brush.setColor( color ); } else { QRadialGradient radialGradient( width()/2, height()/2, diameter/2 ); radialGradient.setColorAt( 0, color ); radialGradient.setColorAt( 1, Qt::transparent ); QBrush brushRadial( radialGradient ); brush.swap( brushRadial ); } painter.setPen( Qt::NoPen ); painter.setBrush( brush ); painter.setOpacity ( opacity ); painter.drawEllipse ( QPoint( width()/2, height()/2 ), diameter/2, diameter/2 ); }
void Box::setFillColour(QColor q) { QBrush br; br.setColor(q); br.setStyle(Qt::SolidPattern); setBrush(br); }
void Draw_Ellipse::setEdgeRects() { QBrush rectbrush; rectbrush.setColor(QColor(0,175,225)); rectbrush.setStyle(Qt::SolidPattern); Strt_Rect = new QGraphicsRectItem(QRectF(QPointF(StrtPnt.x()-5.0,StrtPnt.y()-5.0),QPointF(StrtPnt.x()+5.0,StrtPnt.y()+5.0))); Strt_Rect->setBrush(rectbrush); End_Rect = new QGraphicsRectItem(QRectF(QPointF(EndPnt.x()-5.0,EndPnt.y()-5.0),QPointF(EndPnt.x()+5.0,EndPnt.y()+5.0))); End_Rect->setBrush(rectbrush); QPointF pnt1,pnt2; pnt1.setX(((StrtPnt.x()+EndPnt.x())/2)-5); pnt1.setY(StrtPnt.y()-20); pnt2.setX(((StrtPnt.x()+EndPnt.x())/2)+5); pnt2.setY(StrtPnt.y()-10); Rot_Rect = new QGraphicsEllipseItem(QRectF(pnt1,pnt2)); Rot_Rect->setBrush(rectbrush); }
void graph2_1::paintEvent(QPaintEvent *) { /***********�����α߿���������**************/ QPainter *painter=new QPainter(this); painter->setRenderHint(QPainter::Antialiasing,true); painter->drawRect(10,10,380,230); QPoint beginPoint(50,200); QPoint xEndPoint(xEndX,xEndY); QPoint yEndPoint(yEndX,yEndY); painter->drawLine(beginPoint,xEndPoint); painter->drawLine(beginPoint,yEndPoint); //*****************����������ͷ*********/ int xOffset=13; brush.setColor(Qt::black); brush.setStyle(Qt::SolidPattern); painter->setBrush(brush); QPoint xarrowRightPoint(xEndX+xOffset,xEndY); QPoint xarrowTopPoint(xEndX,-xOffset*tan(PI/6)+xEndY); QPoint xarrowBotPoint(xEndX,xOffset*tan(PI/6)+xEndY); static const QPoint xarrowPoints[3] = { xarrowRightPoint,xarrowTopPoint,xarrowBotPoint, }; painter->drawPolygon(xarrowPoints,3); QPoint yarrowTopPoint(yEndX,yEndY-xOffset); QPoint yarrowRightPoint(xOffset*tan(PI/6)+yEndX,yEndY); QPoint yarrowLeftPoint(-xOffset*tan(PI/6)+yEndX,yEndY); static const QPoint yarrowPoints[3] = { yarrowTopPoint,yarrowLeftPoint,yarrowRightPoint, }; painter->drawPolygon(yarrowPoints,3); painter->setBrush(Qt::NoBrush); /************��ע������**********/ painter->drawText(xEndX,xEndY+20,tr("HZ")); //painter->rotate(270); painter->drawText(yEndY,yEndX+20,tr("dB")); //painter->rotate(90); /*************************/ QVector<qreal> dashes; qreal space = 3; dashes << 5 << space << 5 << space; pen.setDashPattern(dashes); pen.setWidth(2); pen.setColor(Qt::blue); painter->setPen(pen); QPoint point5(90,200); QPoint point6(100,155); QPoint point7(250,110); QPoint point8(300,80); painter->drawPath(drawBezierCurve(point5,point6)); painter->drawPath(drawBezierCurve(point6,point7)); painter->drawPath(drawBezierCurve(point7,point8)); }
void Editor::onMapReady() { myUi->graphicsView->scene()->setSceneRect(0, 0, myGame->generator()->width(), myGame->generator()->height()); for (unsigned int i = 0; i < myGame->generator()->regions().size(); i++) { QPolygonF qring, sqring; auto ring = boost::geometry::exterior_ring(myGame->generator()->regions()[i].poly); boost::geometry::convert(ring, qring); boost::geometry::simplify(qring, sqring, 1); QPen pen; pen.setColor(QColor(0,0,0)); pen.setStyle(Qt::PenStyle::DashLine); QBrush brush; brush.setStyle(Qt::BrushStyle::SolidPattern); std::string colour = myGame->biomes()[myGame->generator()->regions()[i].biome]->jsonValue["mapColour"].asString(); pen.setColor(QColor(colour.c_str())); brush.setColor(QColor(colour.c_str())); QGraphicsPolygonItem * pi = new RegionPolygonItem(this); pi->setPen(pen); pi->setBrush(brush); pi->setPolygon(sqring); QPolygonF convex; boost::geometry::convex_hull(sqring, convex); double area = boost::geometry::area(convex); pi->setZValue(-area); pi->setData(0, i); pi->setFlag(QGraphicsItem::GraphicsItemFlag::ItemIsFocusable, true); pi->setFlag(QGraphicsItem::GraphicsItemFlag::ItemIsSelectable, true); myUi->graphicsView->scene()->addItem(pi); } }
void koregui::FrameBufferStageItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget) { QBrush b; QPen p; QFont font("Arial"); QStaticText text; p.setStyle(Qt::PenStyle::NoPen); b.setColor((isSelected())?QColor(86,86,86):QColor(44,44,44)); b.setStyle(Qt::BrushStyle::SolidPattern); painter->setPen(p); painter->setBrush(b); painter->drawRect(0, 0, _bufferwidth, _bufferheight); font.setBold(true); font.setPointSize(12); painter->setFont(font); text.setText(_name.c_str()); p.setColor(QColor(255,255,255)); p.setStyle(Qt::PenStyle::SolidLine); painter->setPen(p); painter->drawStaticText(10,10, text); painter->drawImage(_bufferwidth - 26, 10, QImage("./assets/icons/gear.png")); }
bool readBrushNode( const QDomElement& element, QBrush& brush ) { bool ok = true; QColor tempColor; Qt::BrushStyle tempStyle; QPixmap tempPixmap; QDomNode node = element.firstChild(); while( !node.isNull() ) { QDomElement element = node.toElement(); if( !element.isNull() ) { // was really an element QString tagName = element.tagName(); if( tagName == "Color" ) { ok = ok & readColorNode( element, tempColor ); } else if( tagName == "Style" ) { QString value; ok = ok & readStringNode( element, value ); tempStyle = stringToBrushStyle( value ); } else if( tagName == "Pixmap" ) { ok = ok & readPixmapNode( element, tempPixmap ); } else { qDebug( "Unknown tag in brush" ); } } node = node.nextSibling(); } if( ok ) { brush.setColor( tempColor ); brush.setStyle( tempStyle ); if( !tempPixmap.isNull() ) brush.setPixmap( tempPixmap ); } return ok; }
BrushPropertyManager::ValueChangedResult BrushPropertyManager::valueChanged(QtVariantPropertyManager *vm, QtProperty *property, const QVariant &value) { switch (value.type()) { case QVariant::Int: // Style subproperty? if (QtProperty *brushProperty = m_brushStyleSubPropertyToProperty.value(property, 0)) { const QBrush oldValue = m_brushValues.value(brushProperty); QBrush newBrush = oldValue; const int index = value.toInt(); newBrush.setStyle(brushStyleIndexToStyle(index)); if (newBrush == oldValue) return Unchanged; vm->variantProperty(brushProperty)->setValue(newBrush); return Changed; } break; case QVariant::Color: // Color subproperty? if (QtProperty *brushProperty = m_brushColorSubPropertyToProperty.value(property, 0)) { const QBrush oldValue = m_brushValues.value(brushProperty); QBrush newBrush = oldValue; newBrush.setColor(qvariant_cast<QColor>(value)); if (newBrush == oldValue) return Unchanged; vm->variantProperty(brushProperty)->setValue(newBrush); return Changed; } break; default: break; } return NoMatch; }
void QGraphVizPIP::drawForeground(QPainter *painter, const QRectF &rect) { if(!rect.intersects(m_ViewPortRect)) { return; } if(m_ViewPortRect.contains(scene()->sceneRect())) { return; } QColor color(Qt::red); QPen pen; pen.setColor(color); painter->setPen(pen); QBrush brush; color.setAlphaF(.1); brush.setColor(color); brush.setStyle(Qt::SolidPattern); painter->setBrush(brush); QRectF sceneRect = this->sceneRect().adjusted(-10,-10,20,20); QRectF viewPortRect; viewPortRect.setLeft(qMax(sceneRect.left(), m_ViewPortRect.left())); viewPortRect.setTop(qMax(sceneRect.top(), m_ViewPortRect.top())); viewPortRect.setRight(qMin(sceneRect.right(), m_ViewPortRect.right())); viewPortRect.setBottom(qMin(sceneRect.bottom(), m_ViewPortRect.bottom())); painter->drawRect(viewPortRect); }
void Canvas::paintEvent(QPaintEvent *event) { QPainter painter(this); QRect dirtyRect = event->rect(); if(dirtyRect.isEmpty())return; // painter.setOpacity(opacity); combineLayers(dirtyRect); painter.drawPixmap(dirtyRect, image, dirtyRect); if(!isEnabled()){ QBrush brush; brush.setStyle(Qt::BDiagPattern); brush.setColor(Qt::lightGray); painter.setBrush(brush); QRect rect = this->rect(); rect.setWidth(rect.width()); rect.setHeight(rect.height()); painter.drawRect(rect); } QStyleOption opt; opt.init(this); style()->drawPrimitive(QStyle::PE_Widget, &opt, &painter, this); }
void RSceneDevice::Circle(double x, double y, double r, R_GE_gcontext *gc) { if (debug) Rprintf("RSceneDevice::Circle\n"); QPen pen(Qt::NoPen); QBrush brush; QRectF rect(x - r, y - r, 2 * r, 2 * r); int col = gc->col; int fill = gc->fill; // double gamma = gc->gamma; double lwd = gc->lwd; int lty = gc->lty; // FIXME: should be easy to add if (col != NA_INTEGER && !R_TRANSPARENT(col)) { pen.setStyle(lty2style(lty)); pen.setColor(r2qColor(col)); pen.setWidthF(lwd); } if (fill != NA_INTEGER && !R_TRANSPARENT(fill)) { brush.setColor(r2qColor(fill)); brush.setStyle(Qt::SolidPattern); } // FIXME: We can either create items separately and add them in // addClippedItem() as here, or do addClippedItem(addEllipse(...)) // which removes and adds (as in the other callbacks currently). // The first is probably better, so should fix the others. addClippedItem(addEllipse(rect, pen, brush)); // QGraphicsEllipseItem *item = new QGraphicsEllipseItem(rect); // item->setPen(pen); // item->setBrush(brush); // addClippedItem(item); return; }
QPixmap KisLightSource::createSelectedBackground() { QPen pen; QBrush brush; QPixmap harhar(m_icondiameter + m_selecthalothickness * 2 + 2, m_icondiameter + m_selecthalothickness * 2 + 2); harhar.fill(QColor(0,0,0,0)); QPainter painter(&harhar); painter.setBackgroundMode(Qt::TransparentMode); painter.setRenderHint(QPainter::Antialiasing, 0x08); pen.setWidth(m_selecthalothickness); pen.setColor(QColor(255, 255, 0)); brush.setStyle(Qt::SolidPattern); brush.setColor(m_color); painter.setBrush(brush); painter.setPen(pen); painter.drawEllipse(m_selecthalothickness, m_selecthalothickness, m_icondiameter - m_selecthalothickness, m_icondiameter - m_selecthalothickness); return harhar; }
void RSceneDevice::Polygon(int n, double *x, double *y, R_GE_gcontext *gc) { if (debug) Rprintf("RSceneDevice::Polygon\n"); QPen pen(Qt::NoPen); QBrush brush; QPolygonF polygon; if (n > 0) { for (int i = 0; i < n; i++) { polygon << QPointF(x[i], y[i]); } // FIXME: do we need to explicitly close the polygon? polygon << QPointF(x[0], y[0]); int col = gc->col; int fill = gc->fill; //double gamma = gc->gamma; double lwd = gc->lwd; int lty = gc->lty; if (col != NA_INTEGER && !R_TRANSPARENT(col)) { pen.setStyle(lty2style(lty)); pen.setColor(r2qColor(col)); pen.setWidthF(lwd); } if (fill != NA_INTEGER && !R_TRANSPARENT(fill)) { brush.setColor(r2qColor(fill)); brush.setStyle(Qt::SolidPattern); } addClippedItem(addPolygon(polygon, pen, brush)); } return; }