Пример #1
0
void PreviewWidget::drawShadow(QPainter &painter, QRectF rect)
{
    // Shadow width
    int width = qBound(4, int(qMax(rect.height(), rect.width())) / 100, 7);

    painter.save();
    painter.setClipRect(rect.adjusted(0, 0, width, width));

    QColor lightColor = this->palette().color(QPalette::Background);
    QColor darkColor  = lightColor.darker(160);

    QRectF shadowRect = rect.adjusted(0, 0, width, width);
    QLinearGradient lg;
    lg.setColorAt(0.0, darkColor);
    lg.setColorAt(1.0, lightColor);


    QRadialGradient rg;
    rg.setColorAt(0, darkColor);
    rg.setColorAt(1, lightColor);
    rg.setRadius(width);


    // Right
    lg.setStart(QPointF(rect.right(), rect.center().y()));
    lg.setFinalStop(QPointF(shadowRect.right(), rect.center().y()));
    painter.fillRect(rect.right(), rect.top() + width, width, rect.height() - width, lg);

    // Bottom
    lg.setStart(rect.center().x(),  rect.bottom());
    lg.setFinalStop(rect.center().x(), rect.bottom() + width);
    painter.fillRect(rect.left() + width, rect.bottom(), rect.width() - width, width, lg);

    //TopRight
    QPointF p;
    p = rect.bottomRight();
    rg.setCenter(p);
    rg.setFocalPoint(p);
    painter.fillRect(rect.right(), rect.bottom(), width, width, rg);

    // BottomRight
    p = rect.topRight();
    p.ry() += width;
    rg.setCenter(p);
    rg.setFocalPoint(p);
    painter.fillRect(rect.right(), rect.top(), width, width, rg);

    //BottomLeft
    p = rect.bottomLeft();
    p.rx() += width;
    rg.setCenter(p);
    rg.setFocalPoint(p);
    painter.fillRect(rect.left(), rect.bottom(), width, width, rg);


    painter.restore();
}
Пример #2
0
void EditorMagnifierItem::updateMask()
{
    QRectF current = getRect();
    QSize box = QSize( current.width(), current.width() );

    // reupdate our mask
    if (m_imgMask.size() != box)
    {
        int radius = box.width() / 2;
        int ring = radius - 10;

        m_imgMask = QPixmap(box);
        m_imgMask.fill(Qt::transparent);

        QRadialGradient g;
        g.setCenter(radius, radius);
        g.setFocalPoint(radius, radius);
        g.setRadius(radius);
        g.setColorAt( 1.0, QColor(255, 255, 255, 0) );
        g.setColorAt( 0.5, QColor(128, 128, 128, 255) );

        QPainter mask(&m_imgMask);
        mask.setRenderHint(QPainter::Antialiasing);
        mask.setCompositionMode(QPainter::CompositionMode_Source);
        mask.setBrush(g);
        mask.setPen(Qt::NoPen);
        mask.drawRect( m_imgMask.rect() );
        mask.setBrush( QColor(Qt::transparent) );
        mask.drawEllipse(g.center(), ring, ring);
        mask.end();
    }
}
Пример #3
0
	int MailTreeDelegate::DrawMessageActionIcons (QPainter *painter,
			const QStyleOptionViewItem& option, const QModelIndex& index, int height) const
	{
		if (Mode_ != MailListMode::Normal)
			return 0;

		if (option.state & QStyle::State_MouseOver)
			return 0;

		const auto& actionsVar = index.data (MailModel::MailRole::MessageActions);
		if (actionsVar.isNull ())
			return 0;

		auto actionInfos = actionsVar.value<QList<MessageListActionInfo>> ();
		if (actionInfos.isEmpty ())
			return 0;

		std::reverse (actionInfos.begin (), actionInfos.end ());

		if (ActionsHintsBalls_)
			height -= Padding * 2;

		painter->save ();
		painter->setRenderHint (QPainter::Antialiasing);

		painter->setPen (Qt::NoPen);

		auto rect = option.rect;
		rect.setLeft (rect.right () - height - Padding);
		rect.setSize ({ height, height });
		rect.moveTop (rect.top () + Padding);
		for (const auto& item : actionInfos)
		{
			if (item.Flags_ & MessageListActionFlag::AlwaysPresent)
				continue;

			if (ActionsHintsBalls_)
			{
				QRadialGradient gradient;
				gradient.setCoordinateMode (QGradient::ObjectBoundingMode);
				gradient.setFocalPoint ({ 0.3, 0.3 });
				gradient.setCenter ({ 0.5, 0.5 });
				gradient.setRadius (0.5);
				gradient.setColorAt (0, item.ReprColor_.lighter (200));
				gradient.setColorAt (1, item.ReprColor_.darker (120));

				painter->setBrush (gradient);
				painter->drawEllipse (rect);
			}
			else
				item.Icon_.paint (painter, rect);

			rect.moveLeft (rect.left () - height - Padding);
		}

		painter->restore ();

		return option.rect.right () - rect.right ();
	}
Пример #4
0
void dot::paint ( QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget )
{
	Q_UNUSED ( widget );

	painter->setPen ( Qt::NoPen );
	painter->setBrush ( Qt::darkGray );
	painter->drawEllipse ( -1, -1, 5, 5 );
	QRadialGradient gradient ( -3, -3, 10 );
	if( this->isSelected() )
	{
		if ( option->state & QStyle::State_Sunken )
		{
			gradient.setCenter ( 3, 3 );
			gradient.setFocalPoint ( 3, 3 );
			gradient.setColorAt ( 1, QColor ( Qt::green ).light ( 100 ) );
			gradient.setColorAt ( 0, QColor ( Qt::darkGreen ).light ( 100 ) );
		}
		else
		{
			gradient.setColorAt ( 0, Qt::green );
			gradient.setColorAt ( 1, Qt::darkGreen );
		}
	}
	else
	{
		if ( option->state & QStyle::State_Sunken )
		{
			gradient.setCenter ( 3, 3 );
			gradient.setFocalPoint ( 3, 3 );
			gradient.setColorAt ( 1, QColor ( Qt::yellow ).light ( 100 ) );
			gradient.setColorAt ( 0, QColor ( Qt::darkYellow ).light ( 100 ) );
		}
		else
		{
			gradient.setColorAt ( 0, Qt::yellow );
			gradient.setColorAt ( 1, Qt::darkYellow );
		}
	}
	painter->setBrush ( gradient );
	painter->setPen ( QPen ( Qt::black, 0 ) );
	painter->drawEllipse ( -2, -2, 6, 6 );
        painter->scale ( 1.0,-1.0 );
        painter->setFont(QFont("Arial", 14));
        painter->drawText(0,10,message);
}
Пример #5
0
void BoxStyle::unoptimizedPaint(QPainter* painter, int xOffset, int yOffset, int contentBoxWidth,
				int contentBoxHeight) const
{
	qreal x = xOffset;
	qreal y = yOffset;

	int outlineWidth = outline_.style()!=Qt::NoPen ? outline_.width() : 0;
	// Move the figure when using antialiasing. The outline will start at a pixel boundary. This makes it sharper.
	if ( painter->testRenderHint(QPainter::Antialiasing) || painter->testRenderHint(QPainter::HighQualityAntialiasing) )
		if ( outline().style() != Qt::NoPen)
		{
			x = xOffset + outlineWidth/2.0;
			y = yOffset + outlineWidth/2.0;
		}

	// Draw shadow
	if ( shadow() != Qt::NoBrush )
	{
		painter->setPen(Qt::NoPen);
		painter->setBrush(shadow());
		painter->drawPath(getRectanglePath(xOffset + xShadowOffset(), yOffset + yShadowOffset(),
				contentBoxWidth, contentBoxHeight));
	}

	// Draw box.
	painter->setPen(outline());

	// Set the brush and fix the gradient if needed.
	if ( background().style() == Qt::LinearGradientPattern
			&& background().gradient()->coordinateMode() == QGradient::LogicalMode )
	{
		QLinearGradient g = *(static_cast<const QLinearGradient*> (background().gradient()));
		g.setStart(x + g.start().x(), y + g.start().y());
		g.setFinalStop(x + g.finalStop().x(), y + g.finalStop().y());
		painter->setBrush(g);

	}
	else if ( background().style()  == Qt::RadialGradientPattern
			&& background().gradient()->coordinateMode() == QGradient::LogicalMode )
	{
		QRadialGradient g = *(static_cast<const QRadialGradient*> (background().gradient()));
		g.setCenter(x + g.center().x(), y + g.center().y());
		g.setFocalPoint(x + g.focalPoint().x(), y + g.focalPoint().y());
		painter->setBrush(g);
	}
	else
	{
		painter->setBrush(background());
	}

	painter->drawPath(getRectanglePath(x, y, contentBoxWidth - outlineWidth, contentBoxHeight - outlineWidth));
}
Пример #6
0
void Highlight::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
    QColor pen_color = pen.color();
    painter->setPen(pen);
    if(time < total_time ){ //don't want to keep adding them past animation length
        int expected_num_rings = (int)ceil(frequency * time);
        if( expected_num_rings > rings.length()){
            rings.append(time);
        }
        //velocity= 200.0 - (time*total_time*2.0);//pretty cool
        //velocity= 200.0*(1.0-done_ratio);//pretty cool, about the same
        //frequency = 3.0*(1.0-done_ratio);//pretty cool
        for(int i=0; i<rings.length(); i++){
            //qreal dist = diameter + ( velocity * (time - rings.at(i)));
            qreal t = (time - rings.at(i));
            qreal dist = diameter + ( velocity * t ) + (0.5 * -5.0 * t*t);
            //qDebug() << "dist:" << dist << " outerDiameter:" << outerDiameter;

            QRectF s(x()-dist/2.0, y()-dist/2.0,dist,dist);
            QRectF r = mapRectFromScene(x()-dist/2.0, y()-dist/2.0,dist,dist);
            pen.setWidth(20.0+50.0* dist/outerDiameter);
            QRadialGradient radialGrad;
            radialGrad.setCenter(r.center());
            radialGrad.setFocalPoint(r.center());
            radialGrad.setCenterRadius(r.width()/2.0+pen.widthF()/2.0);
            radialGrad.setFocalRadius(r.width()/2.0-pen.widthF()/2.0);
            /* not entirely sure I get it, but I think focal radius
     * needs to be either the center of the pen or its inner edge
     * while center radius is the outer edge.
    */

            QColor green(0,255,0,255);
            QColor yellow(255,255,0,255);
            /*
            pen_color.setAlphaF(1.0-(dist/outerDiameter)); //surface waves don't inverse square
            */
            green.setAlphaF(1.0-(dist/outerDiameter));
            yellow.setAlphaF((1.0-(dist/outerDiameter)));

            radialGrad.setColorAt(.0, yellow );
            radialGrad.setColorAt( .5, green );
            radialGrad.setColorAt(1, yellow );

            brush = QBrush(radialGrad);
            pen.setBrush(brush);
            painter->setPen(pen);
            painter->drawEllipse(r);
        }

    }

}
Пример #7
0
void tst_QBrush::testQRadialGradientSetters()
{
    QRadialGradient rg;

    QCOMPARE(rg.radius(), qreal(1.0));
    QCOMPARE(rg.center(), QPointF(0, 0));
    QCOMPARE(rg.focalPoint(), QPointF(0, 0));

    rg.setRadius(100);
    QCOMPARE(rg.radius(), qreal(100.0));

    rg.setCenter(101, 102);
    QCOMPARE(rg.center(), QPointF(101, 102));

    rg.setCenter(QPointF(201, 202));
    QCOMPARE(rg.center(), QPointF(201, 202));

    rg.setFocalPoint(103, 104);
    QCOMPARE(rg.focalPoint(), QPointF(103, 104));

    rg.setFocalPoint(QPointF(203, 204));
    QCOMPARE(rg.focalPoint(), QPointF(203, 204));
}
Пример #8
0
void PainterWidget::updateBrush()
{
    QRadialGradient g;
    g.setCenter(brush_size/2, brush_size/2);
    g.setFocalPoint(brush_size/2, brush_size/2);
    g.setRadius(brush_size/2);
    g.setColorAt(1.0, Qt::black);
    g.setColorAt(0, QColor(100,100,100));

    QImage mask(brush_size, brush_size,QImage::Format_RGB32);
    mask.fill(qRgb(0,0,0));
    QPainter painter2(&mask);
    painter2.fillRect(mask.rect(), g);
    painter2.end();
    soft_brush = QImage(brush_size, brush_size,QImage::Format_RGB32);
    soft_brush.fill(brush_color.rgb());
    soft_brush.setAlphaChannel(mask);
}
static QGradient loadGradient(const QDomElement &elem)
{
    if (elem.tagName() != QLatin1String("gradientData"))
        return QLinearGradient();

    const QGradient::Type type = stringToGradientType(elem.attribute(QLatin1String("type")));
    const QGradient::Spread spread = stringToGradientSpread(elem.attribute(QLatin1String("spread")));
    const QGradient::CoordinateMode mode = stringToGradientCoordinateMode(elem.attribute(QLatin1String("coordinateMode")));

    QGradient gradient = QLinearGradient();

    if (type == QGradient::LinearGradient) {
        QLinearGradient g;
        g.setStart(elem.attribute(QLatin1String("startX")).toDouble(), elem.attribute(QLatin1String("startY")).toDouble());
        g.setFinalStop(elem.attribute(QLatin1String("endX")).toDouble(), elem.attribute(QLatin1String("endY")).toDouble());
        gradient = g;
    } else if (type == QGradient::RadialGradient) {
        QRadialGradient g;
        g.setCenter(elem.attribute(QLatin1String("centerX")).toDouble(), elem.attribute(QLatin1String("centerY")).toDouble());
        g.setFocalPoint(elem.attribute(QLatin1String("focalX")).toDouble(), elem.attribute(QLatin1String("focalY")).toDouble());
        g.setRadius(elem.attribute(QLatin1String("radius")).toDouble());
        gradient = g;
    } else if (type == QGradient::ConicalGradient) {
        QConicalGradient g;
        g.setCenter(elem.attribute(QLatin1String("centerX")).toDouble(), elem.attribute(QLatin1String("centerY")).toDouble());
        g.setAngle(elem.attribute(QLatin1String("angle")).toDouble());
        gradient = g;
    }

    QDomElement stopElem = elem.firstChildElement();
    while (!stopElem.isNull()) {
        QGradientStop stop = loadGradientStop(stopElem);

        gradient.setColorAt(stop.first, stop.second);

        stopElem = stopElem.nextSiblingElement();
    }

    gradient.setSpread(spread);
    gradient.setCoordinateMode(mode);

    return gradient;
}
Пример #10
0
void BitmapImage::drawEllipse( QRectF rectangle, QPen pen, QBrush brush, QPainter::CompositionMode cm, bool antialiasing)
{
    int width = pen.width();
    extend( rectangle.adjusted(-width,-width,width,width).toRect() );
    if (brush.style() == Qt::RadialGradientPattern)
    {
        QRadialGradient* gradient = (QRadialGradient*)brush.gradient();
        gradient->setCenter( gradient->center() - topLeft() );
        gradient->setFocalPoint( gradient->focalPoint() - topLeft() );
    }
    if (mImage != NULL && !mImage->isNull() )
    {
        QPainter painter(mImage);
        painter.setCompositionMode(cm);
        painter.setRenderHint(QPainter::Antialiasing, antialiasing);
        painter.setPen(pen);
        painter.setBrush(brush);
        //if (brush == Qt::NoBrush)
        painter.drawEllipse( rectangle.translated(-topLeft()) );
        painter.end();
    }
}
Пример #11
0
void BitmapImage::drawRect(QRectF rectangle, QPen pen, QBrush brush, QPainter::CompositionMode cm, bool antialiasing)
{
    int width = pen.width();
    setCompositionModeBounds(rectangle.adjusted(-width, -width, width, width).toRect(), true, cm);
    if (brush.style() == Qt::RadialGradientPattern)
    {
        QRadialGradient* gradient = (QRadialGradient*)brush.gradient();
        gradient->setCenter(gradient->center() - mBounds.topLeft());
        gradient->setFocalPoint(gradient->focalPoint() - mBounds.topLeft());
    }
    if (!image()->isNull())
    {
        QPainter painter(image());
        painter.setCompositionMode(cm);
        painter.setRenderHint(QPainter::Antialiasing, antialiasing);
        painter.setPen(pen);
        painter.setBrush(brush);
        painter.drawRect(rectangle.translated(-mBounds.topLeft()));
        painter.end();
    }
    modification();
}
Пример #12
0
SpaceObjectSun::SpaceObjectSun(int x, int y)
  : SpaceObject(x, y, SO_TYPE_SUN)
{
  mPixmap->fill(Qt::transparent);

  QPainter p(mPixmap);

  QRadialGradient rd;

  rd.setCenter(40, 40);
  rd.setRadius(40);
  rd.setFocalPoint(40, 40);

  rd.setColorAt(0, QColor(0xFF, 0xFF, 0xDD, 0xFF));
  rd.setColorAt(0.45, QColor(0xFF, 0xFF, 0xDD, 0xFF));
  rd.setColorAt(0.55, QColor(0xFF, 0xFF, 0x33, 0xFF));
  rd.setColorAt(0.6, QColor("#FF9900"));

  rd.setColorAt(1, QColor( 0, 0, 0, 0x00 ));

  p.setPen(Qt::NoPen);
  p.setBrush( rd );
  p.drawEllipse(0, 0, 80, 80);
}
Пример #13
0
/**
 * 重绘
 * 实现只出现垂直滚动条的重载的画图事件处理方法。
 * 
 */
void TaskBallMapWidget::paintEvent(QPaintEvent * event ) 
{
	// qLogx()<< __FUNCTION__ <<this->mBallBit.size()<<this->mBallMap.size()<<this->mCurrentTaskId;
	QBrush brush(QColor(0, 0, 0));

	//依靠currtaskid 判断是否需要重绘
	if (this->mCurrentTaskId < 0) {
		return;
	}
    if (this->mBallBit.size() <= 0) {
        qLogx()<<__FUNCTION__<<QString("No bit set,");
        // leave the widget raw clear
        return;
    }

	//计算图象应该具有的宽度,splitter是以线性变化,而图形则必须以非线性变化,需要对取到的窗口宽度进行圆整
	int width = this->mp->size().width() - 20 ;
	if (width % (this->mBallRadius*2) != 0 ) {
		width = ( (width / (this->mBallRadius*2)) ) * ( this->mBallRadius * 2)  ;
	} else {
		width = (width / (this->mBallRadius*2)) * ( this->mBallRadius * 2)  ;
	}
	//窗口的高度。
	int height = this->mBallMap.height() ;

	if (width != this->mBallMap.width()) {
		//qLogx()<< "change to width:" << width ;
		//需要改变图象大小。宽度
		this->mBallMap = QImage(width , this->mBallMap.height() , QImage::Format_ARGB32_Premultiplied);
		//this->mBallMap = this->mBallMap.scaledToWidth( width ) ; 
		//this->resize(width,height);
		this->setFixedWidth( width );
	}

	if (this->mBallBit.size() != (width/(this->mBallRadius*2)) * (height/(this->mBallRadius*2))) {
		height = (this->mBallRadius*2) * (this->mBallBit.size())/((width/(this->mBallRadius*2)));
		if (height % (this->mBallRadius*2) != 0 ) {
			height = ( 1+ (height / (this->mBallRadius*2)) ) * ( this->mBallRadius * 2);
		} else {
			height = ( height / (this->mBallRadius*2) ) * ( this->mBallRadius * 2);
		}

		//qLogx()<< "change to height: " << height ;
		//需要改变图象大小。高度。
		//this->mBallMap = this->mBallMap.scaledToHeight( (this->mCurrentLength / (this->mBlockSize))/((width/(this->mBallRadius*2)) ) * ( this->mBallRadius*2 ));
		this->mBallMap =  QImage(width, height, QImage::Format_ARGB32_Premultiplied);
		//this->mBallMap =  this->mBallMap.scaledToHeight(height);

		//this->resize(width,height);
		this->setFixedHeight(height);	//设置本窗口构件的大小,使得外层的滚动构件能适当的添加或者删除滚动条。
	}
    //  ball ball 48 0 // 0 true 600 0 
    
    // qLogx()<<__FUNCTION__<<this->mBallBit.size()<<this->mBallMap.isNull()<<width<<height;
    if (this->mBallMap.isNull()) {
        /*
          if not check, show this error:
          QPainter::begin: Paint device returned engine == 0, type: 3
          QPainter::setRenderHint: Painter must be active to set rendering hints
          QPainter::setBrush: Painter not active
          QPainter::drawRects: Painter not active
          QPainter::setBrush: Painter not active
          QPainter::setBrush: Painter not actiev
         */
        // this->mBallMap = QImage(mp->width(), mp->height(), QImage::Format_ARGB32_Premultiplied);
        return;
    }

	QPainter imgp(&this->mBallMap) ;
	imgp.setRenderHint(QPainter::Antialiasing, true);
	imgp.setBrush(brush) ;
	imgp.drawRect(0, 0, this->mBallMap.width(), this->mBallMap.height());

	//更改前景颜色。
	brush.setColor(QColor(0,255,0));
	imgp.setBrush(brush);

	//////////
	QRadialGradient radgrad ;	//梯度法
	imgp.setBrush(radgrad) ;

	int row = 0 , col = 0 ;	//当前行,列
	int mrow , mcol ;		//最大行,列
	int srow , scol ;		//当前球块所在行,列。
	mcol = width / (this->mBallRadius*2) ;
	mrow = this->mBallBit.size() % mcol == 0 ? 
        (this->mBallBit.size() / mcol) : (this->mBallBit.size() / mcol + 1);
	int mtb = this->mBallBit.size();	//所有球的个数。

    // qLogx()<<"rows:"<<mrow<<"cols:"<<mcol;
    for (int row = 0; row < mrow; row++) {
        int sballno;
        
        for (int col=0; col < mcol ; col ++) {
            int bx, by, bw, bh;
            sballno = row * mcol + col;   //本球块在整个文件块中的序号。
            if (sballno >= this->mBallBit.size()) {
                break;
            }
            if (this->mBallBit.testBit(sballno) == false) {
                continue;
            }
            bx = col * this->mBallRadius * 2; //本求块的右上角X值。
            by = row * this->mBallRadius * 2; //本求块的右上角Y值。

			//qLogx()<<"x,y,w"<<bx<<by<<(this->mBallRadius*2);
			radgrad.setCenter(bx+this->mBallRadius, by + this->mBallRadius);	//梯度参数设置
			radgrad.setRadius(this->mBallRadius * 2 );
			radgrad.setFocalPoint(bx+this->mBallRadius/2,by+this->mBallRadius/2);
			radgrad.setColorAt(0.0,QColor(255,255,255));
			radgrad.setColorAt(0.5,QColor(0,255,0));
			radgrad.setColorAt(1.0,QColor(0,0,0));
			imgp.setBrush(radgrad);
			imgp.drawEllipse(bx,by,this->mBallRadius*2 , this->mBallRadius*2);
        }
    }

	//输出到屏幕。
	QPainter scrp(this);
	scrp.drawImage(0, 0, this->mBallMap);
}
void AbstractDiagram::paintMarker( QPainter* painter,
                                   const MarkerAttributes& markerAttributes,
                                   const QBrush& brush,
                                   const QPen& pen,
                                   const QPointF& pos,
                                   const QSizeF& maSize )
{
    const QPen oldPen( painter->pen() );
    // Pen is used to paint 4Pixels - 1 Pixel - Ring and FastCross types.
    // make sure to use the brush color - see above in those cases.
    const bool isFourPixels = (markerAttributes.markerStyle() == MarkerAttributes::Marker4Pixels);
    if( isFourPixels || (markerAttributes.markerStyle() == MarkerAttributes::Marker1Pixel) ){
        // for high-performance point charts with tiny point markers:
        painter->setPen( PrintingParameters::scalePen( QPen( brush.color().light() ) ) );
        if( isFourPixels ){
            const qreal x = pos.x();
            const qreal y = pos.y();
            painter->drawLine( QPointF(x-1.0,y-1.0),
                               QPointF(x+1.0,y-1.0) );
            painter->drawLine( QPointF(x-1.0,y),
                               QPointF(x+1.0,y) );
            painter->drawLine( QPointF(x-1.0,y+1.0),
                               QPointF(x+1.0,y+1.0) );
        }
        painter->drawPoint( pos );
    }else{
        const PainterSaver painterSaver( painter );
        // we only a solid line surrounding the markers
        QPen painterPen( pen );
        painterPen.setStyle( Qt::SolidLine );
        painter->setPen( PrintingParameters::scalePen( painterPen ) );
        painter->setBrush( brush );
        painter->setRenderHint ( QPainter::Antialiasing );
        painter->translate( pos );
        switch ( markerAttributes.markerStyle() ) {
            case MarkerAttributes::MarkerCircle:
            {
                if ( markerAttributes.threeD() ) {
                    QRadialGradient grad;
                    grad.setCoordinateMode( QGradient::ObjectBoundingMode );
                    QColor drawColor = brush.color();
                    grad.setCenter( 0.5, 0.5 );
                    grad.setRadius( 1.0 );
                    grad.setFocalPoint( 0.35, 0.35 );
                    grad.setColorAt( 0.00, drawColor.lighter( 150 ) );
                    grad.setColorAt( 0.20, drawColor );
                    grad.setColorAt( 0.50, drawColor.darker( 150 ) );
                    grad.setColorAt( 0.75, drawColor.darker( 200 ) );
                    grad.setColorAt( 0.95, drawColor.darker( 250 ) );
                    grad.setColorAt( 1.00, drawColor.darker( 200 ) );
                    QBrush newBrush( grad );
                    newBrush.setMatrix( brush.matrix() );
                    painter->setBrush( newBrush );
                }
                painter->drawEllipse( QRectF( 0 - maSize.height()/2, 0 - maSize.width()/2,
                            maSize.height(), maSize.width()) );
            }
                break;
            case MarkerAttributes::MarkerSquare:
                {
                    QRectF rect( 0 - maSize.width()/2, 0 - maSize.height()/2,
                                maSize.width(), maSize.height() );
                    painter->drawRect( rect );
                    break;
                }
            case MarkerAttributes::MarkerDiamond:
                {
                    QVector <QPointF > diamondPoints;
                    QPointF top, left, bottom, right;
                    top    = QPointF( 0, 0 - maSize.height()/2 );
                    left   = QPointF( 0 - maSize.width()/2, 0 );
                    bottom = QPointF( 0, maSize.height()/2 );
                    right  = QPointF( maSize.width()/2, 0 );
                    diamondPoints << top << left << bottom << right;
                    painter->drawPolygon( diamondPoints );
                    break;
                }
            // both handled on top of the method:
            case MarkerAttributes::Marker1Pixel:
            case MarkerAttributes::Marker4Pixels:
                    break;
            case MarkerAttributes::MarkerRing:
                {
                    painter->setPen( PrintingParameters::scalePen( QPen( brush.color() ) ) );
                    painter->setBrush( Qt::NoBrush );
                    painter->drawEllipse( QRectF( 0 - maSize.height()/2, 0 - maSize.width()/2,
                                        maSize.height(), maSize.width()) );
                    break;
                }
            case MarkerAttributes::MarkerCross:
                {
                    // Note: Markers can have outline,
                    //       so just drawing two rects is NOT the solution here!
                    const qreal w02 = maSize.width() * 0.2;
                    const qreal w05 = maSize.width() * 0.5;
                    const qreal h02 = maSize.height()* 0.2;
                    const qreal h05 = maSize.height()* 0.5;
                    QVector <QPointF > crossPoints;
                    QPointF p[12];
                    p[ 0] = QPointF( -w02, -h05 );
                    p[ 1] = QPointF(  w02, -h05 );
                    p[ 2] = QPointF(  w02, -h02 );
                    p[ 3] = QPointF(  w05, -h02 );
                    p[ 4] = QPointF(  w05,  h02 );
                    p[ 5] = QPointF(  w02,  h02 );
                    p[ 6] = QPointF(  w02,  h05 );
                    p[ 7] = QPointF( -w02,  h05 );
                    p[ 8] = QPointF( -w02,  h02 );
                    p[ 9] = QPointF( -w05,  h02 );
                    p[10] = QPointF( -w05, -h02 );
                    p[11] = QPointF( -w02, -h02 );
                    for( int i=0; i<12; ++i )
                        crossPoints << p[i];
                    crossPoints << p[0];
                    painter->drawPolygon( crossPoints );
                    break;
                }
            case MarkerAttributes::MarkerFastCross:
                {
                    QPointF left, right, top, bottom;
                    left  = QPointF( -maSize.width()/2, 0 );
                    right = QPointF( maSize.width()/2, 0 );
                    top   = QPointF( 0, -maSize.height()/2 );
                    bottom= QPointF( 0, maSize.height()/2 );
                    painter->setPen( PrintingParameters::scalePen( QPen( brush.color() ) ) );
                    painter->drawLine( left, right );
                    painter->drawLine(  top, bottom );
                    break;
                }
            case MarkerAttributes::NoMarker:
                break;
            default:
                Q_ASSERT_X ( false, "paintMarkers()",
                            "Type item does not match a defined Marker Type." );
        }
    }
    painter->setPen( oldPen );
}
Пример #15
0
bool SvgParser::parseGradient(const KoXmlElement &e, const KoXmlElement &referencedBy)
{
    // IMPROVEMENTS:
    // - Store the parsed colorstops in some sort of a cache so they don't need to be parsed again.
    // - A gradient inherits attributes it does not have from the referencing gradient.
    // - Gradients with no color stops have no fill or stroke.
    // - Gradients with one color stop have a solid color.

    SvgGraphicsContext *gc = m_context.currentGC();
    if (!gc)
        return false;

    SvgGradientHelper gradhelper;

    if (e.hasAttribute("xlink:href")) {
        QString href = e.attribute("xlink:href").mid(1);
        if (! href.isEmpty()) {
            // copy the referenced gradient if found
            SvgGradientHelper *pGrad = findGradient(href);
            if (pGrad)
                gradhelper = *pGrad;
        } else {
            //gc->fillType = SvgGraphicsContext::None; // <--- TODO Fill OR Stroke are none
            return false;
        }
    }

    // Use the gradient that is referencing, or if there isn't one, the original gradient.
    KoXmlElement b;
    if (!referencedBy.isNull())
        b = referencedBy;
    else
        b = e;

    QString gradientId = b.attribute("id");

    if (! gradientId.isEmpty()) {
        // check if we have this gradient already parsed
        // copy existing gradient if it exists
        if (m_gradients.find(gradientId) != m_gradients.end())
            gradhelper.copyGradient(m_gradients[ gradientId ].gradient());
    }

    if (b.attribute("gradientUnits") == "userSpaceOnUse")
        gradhelper.setGradientUnits(SvgGradientHelper::UserSpaceOnUse);

    // parse color prop
    QColor c = gc->currentColor;

    if (!b.attribute("color").isEmpty()) {
        m_context.styleParser().parseColor(c, b.attribute("color"));
    } else {
        // try style attr
        QString style = b.attribute("style").simplified();
        const QStringList substyles = style.split(';', QString::SkipEmptyParts);
        for (QStringList::ConstIterator it = substyles.begin(); it != substyles.end(); ++it) {
            QStringList substyle = it->split(':');
            QString command = substyle[0].trimmed();
            QString params  = substyle[1].trimmed();
            if (command == "color")
                m_context.styleParser().parseColor(c, params);
        }
    }
    gc->currentColor = c;

    if (b.tagName() == "linearGradient") {
        QLinearGradient *g = new QLinearGradient();
        if (gradhelper.gradientUnits() == SvgGradientHelper::ObjectBoundingBox) {
            g->setCoordinateMode(QGradient::ObjectBoundingMode);
            g->setStart(QPointF(SvgUtil::fromPercentage(b.attribute("x1", "0%")),
                                SvgUtil::fromPercentage(b.attribute("y1", "0%"))));
            g->setFinalStop(QPointF(SvgUtil::fromPercentage(b.attribute("x2", "100%")),
                                    SvgUtil::fromPercentage(b.attribute("y2", "0%"))));
        } else {
            g->setStart(QPointF(SvgUtil::fromUserSpace(b.attribute("x1").toDouble()),
                                SvgUtil::fromUserSpace(b.attribute("y1").toDouble())));
            g->setFinalStop(QPointF(SvgUtil::fromUserSpace(b.attribute("x2").toDouble()),
                                    SvgUtil::fromUserSpace(b.attribute("y2").toDouble())));
        }
        // preserve color stops
        if (gradhelper.gradient())
            g->setStops(gradhelper.gradient()->stops());
        gradhelper.setGradient(g);
    } else if (b.tagName() == "radialGradient") {
        QRadialGradient *g = new QRadialGradient();
        if (gradhelper.gradientUnits() == SvgGradientHelper::ObjectBoundingBox) {
            g->setCoordinateMode(QGradient::ObjectBoundingMode);
            g->setCenter(QPointF(SvgUtil::fromPercentage(b.attribute("cx", "50%")),
                                 SvgUtil::fromPercentage(b.attribute("cy", "50%"))));
            g->setRadius(SvgUtil::fromPercentage(b.attribute("r", "50%")));
            g->setFocalPoint(QPointF(SvgUtil::fromPercentage(b.attribute("fx", "50%")),
                                     SvgUtil::fromPercentage(b.attribute("fy", "50%"))));
        } else {
            g->setCenter(QPointF(SvgUtil::fromUserSpace(b.attribute("cx").toDouble()),
                                 SvgUtil::fromUserSpace(b.attribute("cy").toDouble())));
            g->setFocalPoint(QPointF(SvgUtil::fromUserSpace(b.attribute("fx").toDouble()),
                                     SvgUtil::fromUserSpace(b.attribute("fy").toDouble())));
            g->setRadius(SvgUtil::fromUserSpace(b.attribute("r").toDouble()));
        }
        // preserve color stops
        if (gradhelper.gradient())
            g->setStops(gradhelper.gradient()->stops());
        gradhelper.setGradient(g);
    } else {
        return false;
    }

    // handle spread method
    QString spreadMethod = b.attribute("spreadMethod");
    if (!spreadMethod.isEmpty()) {
        if (spreadMethod == "reflect")
            gradhelper.gradient()->setSpread(QGradient::ReflectSpread);
        else if (spreadMethod == "repeat")
            gradhelper.gradient()->setSpread(QGradient::RepeatSpread);
        else
            gradhelper.gradient()->setSpread(QGradient::PadSpread);
    } else
        gradhelper.gradient()->setSpread(QGradient::PadSpread);

    // Parse the color stops. The referencing gradient does not have colorstops,
    // so use the stops from the gradient it references to (e in this case and not b)
    m_context.styleParser().parseColorStops(gradhelper.gradient(), e);
    gradhelper.setTransform(SvgUtil::parseTransform(b.attribute("gradientTransform")));
    m_gradients.insert(gradientId, gradhelper);

    return true;
}
Пример #16
0
QBrush XMLParseBase::parseGradient(const QDomElement &element)
{
    QBrush brush;
    QString gradientStart = element.attribute("start", "");
    QString gradientEnd = element.attribute("end", "");
    int gradientAlpha = element.attribute("alpha", "255").toInt();
    QString direction = element.attribute("direction", "vertical");

    QGradientStops stops;

    if (!gradientStart.isEmpty())
    {
        QColor startColor = QColor(gradientStart);
        startColor.setAlpha(gradientAlpha);
        QGradientStop stop(0.0, startColor);
        stops.append(stop);
    }

    for (QDomNode child = element.firstChild(); !child.isNull();
        child = child.nextSibling())
    {
        QDomElement childElem = child.toElement();
        if (childElem.tagName() == "stop")
        {
            float position = childElem.attribute("position", "0").toFloat();
            QString color = childElem.attribute("color", "");
            int alpha = childElem.attribute("alpha", "-1").toInt();
            if (alpha < 0)
                alpha = gradientAlpha;
            QColor stopColor = QColor(color);
            stopColor.setAlpha(alpha);
            QGradientStop stop((position / 100), stopColor);
            stops.append(stop);
        }
    }

    if (!gradientEnd.isEmpty())
    {
        QColor endColor = QColor(gradientEnd);
        endColor.setAlpha(gradientAlpha);
        QGradientStop stop(1.0, endColor);
        stops.append(stop);
    }

    if (direction == "radial")
    {
        QRadialGradient gradient;
        gradient.setCoordinateMode(QGradient::ObjectBoundingMode);
        float x1 = 0.5, y1 = 0.5, radius = 0.5;
        gradient.setCenter(x1,y1);
        gradient.setFocalPoint(x1,y1);
        gradient.setRadius(radius);
        gradient.setStops(stops);
        brush = QBrush(gradient);
    }
    else // Linear
    {
        QLinearGradient gradient;
        gradient.setCoordinateMode(QGradient::ObjectBoundingMode);
        float x1 = 0.0, y1 = 0.0, x2 = 0.0, y2 = 0.0;
        if (direction == "vertical")
        {
            x1 = 0.5;
            x2 = 0.5;
            y1 = 0.0;
            y2 = 1.0;
        }
        else if (direction == "diagonal")
        {
            x1 = 0.0;
            x2 = 1.0;
            y1 = 0.0;
            y2 = 1.0;
        }
        else // Horizontal
        {
            x1 = 0.0;
            x2 = 1.0;
            y1 = 0.5;
            y2 = 0.5;
        }

        gradient.setStart(x1, y1);
        gradient.setFinalStop(x2, y2);
        gradient.setStops(stops);
        brush = QBrush(gradient);
    }


    return brush;
}
Пример #17
0
void transferGradientPosition(const QGradient * srcGradient, QGradient * dstGradient)
{
    // first check if gradients have the same type
    if (srcGradient->type() == dstGradient->type()) {
        switch (srcGradient->type()) {
        case QGradient::LinearGradient: {
            const QLinearGradient * src = static_cast<const QLinearGradient*>(srcGradient);
            QLinearGradient * dst = static_cast<QLinearGradient*>(dstGradient);
            dst->setStart(src->start());
            dst->setFinalStop(src->finalStop());
            break;
        }
        case QGradient::RadialGradient: {
            const QRadialGradient * src = static_cast<const QRadialGradient*>(srcGradient);
            QRadialGradient * dst = static_cast<QRadialGradient*>(dstGradient);
            dst->setCenter(src->center());
            dst->setRadius(src->radius());
            dst->setFocalPoint(src->focalPoint());
            break;
        }
        case QGradient::ConicalGradient: {
            const QConicalGradient * src = static_cast<const QConicalGradient*>(srcGradient);
            QConicalGradient * dst = static_cast<QConicalGradient*>(dstGradient);
            dst->setCenter(src->center());
            dst->setAngle(src->angle());
            break;
        }
        default:
            return;
        }
        return;
    }

    // try to preserve gradient positions as best as possible
    QPointF start, stop;
    switch (srcGradient->type()) {
    case QGradient::LinearGradient: {
        const QLinearGradient * g = static_cast<const QLinearGradient*>(srcGradient);
        start = g->start();
        stop = g->finalStop();
        break;
    }
    case QGradient::RadialGradient: {
        const QRadialGradient * g = static_cast<const QRadialGradient*>(srcGradient);
        start = g->center();
        stop = QPointF(g->radius(), 0.0);
        break;
    }
    case QGradient::ConicalGradient: {
        const QConicalGradient * g = static_cast<const QConicalGradient*>(srcGradient);
        start = g->center();
        qreal radAngle = g->angle() * M_PI / 180.0;
        stop = QPointF(50.0 * cos(radAngle), 50.*sin(radAngle));
        break;
    }
    default:
        start = QPointF(0.0, 0.0);
        stop = QPointF(50.0, 50.0);
    }

    switch (dstGradient->type()) {
    case QGradient::LinearGradient: {
        QLinearGradient * g = static_cast<QLinearGradient*>(dstGradient);
        g->setStart(start);
        g->setFinalStop(stop);
        break;
    }
    case QGradient::RadialGradient: {
        QRadialGradient * g = static_cast<QRadialGradient*>(dstGradient);
        QPointF diff = stop - start;
        qreal radius = sqrt(diff.x() * diff.x() + diff.y() * diff.y());
        g->setCenter(start);
        g->setFocalPoint(start);
        g->setRadius(radius);
        break;
    }
    case QGradient::ConicalGradient: {
        QConicalGradient * g = static_cast<QConicalGradient*>(dstGradient);
        QPointF diff = stop - start;
        qreal angle = atan2(diff.y(), diff.x());
        if (angle < 0.0)
            angle += 2 * M_PI;
        g->setCenter(start);
        g->setAngle(angle*180 / M_PI);
        break;
    }
    default:
        return;
    }
}
Пример #18
0
QPixmap ThumbBarDock::generateFuzzyRect(const QSize& size, const QColor& color, int radius)
{
    QPixmap pix(size);
    pix.fill(Qt::transparent);

    QPainter painter(&pix);
    painter.setRenderHint(QPainter::Antialiasing, true);

    // Draw corners ----------------------------------

    QRadialGradient gradient;
    gradient.setColorAt(1, Qt::transparent);
    gradient.setColorAt(0, color);
    gradient.setRadius(radius);
    QPoint center;

    // Top Left
    center = QPoint(radius, radius);
    gradient.setCenter(center);
    gradient.setFocalPoint(center);
    painter.fillRect(0, 0, radius, radius, gradient);

    // Top right
    center = QPoint(size.width() - radius, radius);
    gradient.setCenter(center);
    gradient.setFocalPoint(center);
    painter.fillRect(center.x(), 0, radius, radius, gradient);

    // Bottom left
    center = QPoint(radius, size.height() - radius);
    gradient.setCenter(center);
    gradient.setFocalPoint(center);
    painter.fillRect(0, center.y(), radius, radius, gradient);

    // Bottom right
    center = QPoint(size.width() - radius, size.height() - radius);
    gradient.setCenter(center);
    gradient.setFocalPoint(center);
    painter.fillRect(center.x(), center.y(), radius, radius, gradient);

    // Draw borders ----------------------------------

    QLinearGradient linearGradient;
    linearGradient.setColorAt(1, Qt::transparent);
    linearGradient.setColorAt(0, color);

    // Top
    linearGradient.setStart(0, radius);
    linearGradient.setFinalStop(0, 0);
    painter.fillRect(radius, 0, size.width() - 2*radius, radius, linearGradient);

    // Bottom
    linearGradient.setStart(0, size.height() - radius);
    linearGradient.setFinalStop(0, size.height());
    painter.fillRect(radius, int(linearGradient.start().y()), size.width() - 2*radius, radius, linearGradient);

    // Left
    linearGradient.setStart(radius, 0);
    linearGradient.setFinalStop(0, 0);
    painter.fillRect(0, radius, radius, size.height() - 2*radius, linearGradient);

    // Right
    linearGradient.setStart(size.width() - radius, 0);
    linearGradient.setFinalStop(size.width(), 0);
    painter.fillRect(int(linearGradient.start().x()), radius, radius, size.height() - 2*radius, linearGradient);
    return pix;
}
Пример #19
0
void Ckeyb::drawPressed(QImage *_img)
{

    if (keyPressedList.isEmpty()) {
        return;
    }

    keyPressing.lock();
    QMapIterator<int, quint64> i(keyPressedList);
    keyPressing.unlock();

    while (i.hasNext()) {
        i.next();
        QRect _rect = getKey(i.key()).Rect;
        _rect.setCoords(_rect.x()*pPC->internalImageRatio,
                        _rect.y()*pPC->internalImageRatio,
                        (_rect.x()+_rect.width())*pPC->internalImageRatio,
                        (_rect.y()+_rect.height())*pPC->internalImageRatio);

        int _m = qMin(_rect.width(), _rect.height())*.25;
        _rect+= QMargins(_m,_m,_m,_m);
        int dim = qMax(_rect.width(), _rect.height());
        int magnifierSize = dim * 2;
        int radius = magnifierSize / 2;
        int ring = radius - 15;
        QSize box = QSize(magnifierSize, magnifierSize);

        QPixmap maskPixmap;
        maskPixmap = QPixmap(box);
        maskPixmap.fill(Qt::transparent);

        QRadialGradient g;
        g.setCenter(radius, radius);
        g.setFocalPoint(radius, radius);
        g.setRadius(radius);
        g.setColorAt(1.0, QColor(64, 64, 64, 0));
        g.setColorAt(0.5, QColor(0, 0, 0, 255));

        QPainter mask(&maskPixmap);
        mask.setRenderHint(QPainter::Antialiasing);
        mask.setCompositionMode(QPainter::CompositionMode_Source);
        mask.setBrush(g);
        mask.setPen(Qt::NoPen);
        mask.drawRect(maskPixmap.rect());
        mask.setBrush(QColor(Qt::transparent));
        mask.drawEllipse(g.center(), ring, ring);
        mask.end();

        QPoint center = _rect.center() - QPoint(0, radius);
        center = center + QPoint(0, radius / 2);
        QPoint corner = center - QPoint(radius, radius);

        QPoint xy = center * 2 - QPoint(radius, radius);

        // only set the dimension to the magnified portion
        QPixmap zoomPixmap = QPixmap(box);
        zoomPixmap.fill(Qt::lightGray);
        QPainter pz(&zoomPixmap);
//        pz.translate(-xy);
        QRect target=QRect(QPoint(0,0),box);
        pz.drawImage(target, *_img,_rect);
        pz.end();

        QPainterPath clipPath;
        clipPath.addEllipse(center, ring, ring);

        QPainter p(_img);
        p.setRenderHint(QPainter::Antialiasing);
        p.setClipPath(clipPath);
        p.drawPixmap(corner, zoomPixmap);
        p.setClipping(false);
        p.drawPixmap(corner, maskPixmap);
        p.setPen(Qt::gray);
        p.drawPath(clipPath);

        p.end();
    }
}
Пример #20
0
void LightMaps::paintEvent(QPaintEvent *event)
{
    QPainter p;
    p.begin(this);
    m_normalMap->render(&p, event->rect());
    p.setPen(Qt::black);
    p.drawText(rect(),  Qt::AlignBottom | Qt::TextWordWrap,
                "Map data CCBYSA 2009 OpenStreetMap.org contributors");
    p.end();

    if (zoomed) {
        int dim = qMin(width(), height());
        int magnifierSize = qMin(MAX_MAGNIFIER, dim * 2 / 3);
        int radius = magnifierSize / 2;
        int ring = radius - 15;
        QSize box = QSize(magnifierSize, magnifierSize);

        // reupdate our mask
        if (maskPixmap.size() != box) {
            maskPixmap = QPixmap(box);
            maskPixmap.fill(Qt::transparent);

            QRadialGradient g;
            g.setCenter(radius, radius);
            g.setFocalPoint(radius, radius);
            g.setRadius(radius);
            g.setColorAt(1.0, QColor(255, 255, 255, 0));
            g.setColorAt(0.5, QColor(128, 128, 128, 255));

            QPainter mask(&maskPixmap);
            mask.setRenderHint(QPainter::Antialiasing);
            mask.setCompositionMode(QPainter::CompositionMode_Source);
            mask.setBrush(g);
            mask.setPen(Qt::NoPen);
            mask.drawRect(maskPixmap.rect());
            mask.setBrush(QColor(Qt::transparent));
            mask.drawEllipse(g.center(), ring, ring);
            mask.end();
        }

        QPoint center = dragPos - QPoint(0, radius);
        center = center + QPoint(0, radius / 2);
        QPoint corner = center - QPoint(radius, radius);

        QPoint xy = center * 2 - QPoint(radius, radius);

        // only set the dimension to the magnified portion
        if (zoomPixmap.size() != box) {
            zoomPixmap = QPixmap(box);
            zoomPixmap.fill(Qt::lightGray);
        }
        if (true) {
            QPainter p(&zoomPixmap);
            p.translate(-xy);
            m_largeMap->render(&p, QRect(xy, box));
            p.end();
        }

        QPainterPath clipPath;
        clipPath.addEllipse(center, ring, ring);

        QPainter p(this);
        p.setRenderHint(QPainter::Antialiasing);
        p.setClipPath(clipPath);
        p.drawPixmap(corner, zoomPixmap);
        p.setClipping(false);
        p.drawPixmap(corner, maskPixmap);
        p.setPen(Qt::gray);
        p.drawPath(clipPath);
    }
    if (invert) {
        QPainter p(this);
        p.setCompositionMode(QPainter::CompositionMode_Difference);
        p.fillRect(event->rect(), Qt::white);
        p.end();
    }
}
Пример #21
0
QPixmap PostEffect::generateFuzzyRect(const QSize& size, const QColor& color, int radius)
{
    QPixmap pix(size);
    const QColor transparent(0, 0, 0, 0);
    pix.fill(transparent);

    QPainter painter(&pix);
    painter.setRenderHint(QPainter::Antialiasing, true);

    // Fill middle
    painter.fillRect(pix.rect().adjusted(radius, radius, -radius, -radius), color);

    // Corners
    QRadialGradient gradient;
    gradient.setColorAt(0, color);
    gradient.setColorAt(1, transparent);
    gradient.setRadius(radius);
    QPoint center;

    // Top Left
    center = QPoint(radius, radius);
    gradient.setCenter(center);
    gradient.setFocalPoint(center);
    painter.fillRect(0, 0, radius, radius, gradient);

    // Top right
    center = QPoint(size.width() - radius, radius);
    gradient.setCenter(center);
    gradient.setFocalPoint(center);
    painter.fillRect(center.x(), 0, radius, radius, gradient);

    // Bottom left
    center = QPoint(radius, size.height() - radius);
    gradient.setCenter(center);
    gradient.setFocalPoint(center);
    painter.fillRect(0, center.y(), radius, radius, gradient);

    // Bottom right
    center = QPoint(size.width() - radius, size.height() - radius);
    gradient.setCenter(center);
    gradient.setFocalPoint(center);
    painter.fillRect(center.x(), center.y(), radius, radius, gradient);

    // Borders
    QLinearGradient linearGradient;
    linearGradient.setColorAt(0, color);
    linearGradient.setColorAt(1, transparent);

    // Top
    linearGradient.setStart(0, radius);
    linearGradient.setFinalStop(0, 0);
    painter.fillRect(radius, 0, size.width() - 2 * radius, radius, linearGradient);

    // Bottom
    linearGradient.setStart(0, size.height() - radius);
    linearGradient.setFinalStop( 0, size.height() );
    painter.fillRect(radius, int( linearGradient.start().y() ), size.width() - 2 * radius, radius, linearGradient);

    // Left
    linearGradient.setStart(radius, 0);
    linearGradient.setFinalStop(0, 0);
    painter.fillRect(0, radius, radius, size.height() - 2 * radius, linearGradient);

    // Right
    linearGradient.setStart(size.width() - radius, 0);
    linearGradient.setFinalStop(size.width(), 0);
    painter.fillRect(int( linearGradient.start().x() ), radius, radius, size.height() - 2 * radius, linearGradient);
    return pix;
}