void HudWindow::resizeEvent(QResizeEvent* event) { Q_UNUSED(event); if (desktopCompositingEnabled) { // Pre-draw the window drop shadow. It only needs to be drawn upon // resize. We do this because applying a blur effect to the drop // shadow is computationally expensive. // First, draw the shadow, using a pleasant gradient. QLinearGradient shadowGradient; shadowGradient.setStart(rect().width() / 2, 0.0); shadowGradient.setFinalStop(rect().width() / 2, rect().height()); shadowGradient.setColorAt(0.0, QColor(0, 0, 0, 20)); shadowGradient.setColorAt(1.0, QColor(0, 0, 0, 200)); QImage unblurredImage ( rect().width(), rect().height(), QImage::Format_ARGB32_Premultiplied ); unblurredImage.fill(Qt::transparent); QPainter painter(&unblurredImage); painter.setRenderHint(QPainter::Antialiasing); painter.setPen(QPen(Qt::NoPen)); painter.setBrush(QBrush(shadowGradient)); painter.drawRoundedRect(rect().adjusted(10, 10, -10, -8), 5, 5); painter.end(); // Now we need to blur the shadow onto its final destination image, // dropShadowImg, which will be drawn on the next paintEvent(). // dropShadowImg = QImage ( rect().width(), rect().height(), QImage::Format_ARGB32_Premultiplied ); dropShadowImg.fill(Qt::transparent); painter.begin(&dropShadowImg); painter.setRenderHint(QPainter::Antialiasing); // Note that the blur only applies to the alpha channel. qt_blurImage(&painter, unblurredImage, 20, true, true); painter.end(); } }
void ViewProfileScale::paintHue () { // Create two spectrums: // 1) one spectrum from red to green // 2) another from green to blue QLinearGradient gradient (QPointF (0.0, height() / 2.0), QPointF (width (), height () / 2.0)); gradient.setColorAt (0.0000, Qt::red); gradient.setColorAt (0.3333, Qt::green); gradient.setColorAt (0.6666, Qt::blue); gradient.setColorAt (1.0000, Qt::red); QPainter painter (this); painter.setPen (Qt::NoPen); QBrush brush (gradient); painter.setBrush (brush); painter.drawRect (0, 0, rect().width (), rect().height ()); }
void GraphWidget::_drawLines() { int width = this->widget->width(); int height = this->widget->height(); QList<float>::iterator it = this->_values.begin(); QList<float>::iterator itEnd = --this->_values.end(); this->_painter.fillRect(this->_image.rect(), QBrush(Qt::white)); QPainterPath path; int pos = width - this->_values.size(); while (pos < 0) { this->_values.removeLast(); pos = width - this->_values.size(); } path.moveTo(pos, height); for (; it != itEnd && width > pos; --itEnd, ++pos) path.lineTo(pos, height - static_cast<int>(*itEnd * height / this->_highest_value)); path.lineTo(pos, height - static_cast<int>(*itEnd * height / this->_highest_value)); path.lineTo(pos + height, height); path.closeSubpath(); QLinearGradient grad; grad.setColorAt(0, QColor(0, 250, 0)); grad.setColorAt(1, QColor(0, 75, 0)); grad.setStart(0, 0); grad.setFinalStop(0, height); this->_painter.setBrush(QBrush(grad)); this->_painter.drawPath(path); }
/** * Décrit le façon de dessiner l'élément sur la scène * * @brief Item_Ope::paint(QPainter *pPainter, const QStyleOptionGraphicsItem * option, QWidget * widget) * @param pPainter le pinceau servant à dessiner sur la scène * @param option Option sur le dessin (pas utile dans notre cas) * @param widget Pointer vers le widget sur lequel l'item sera peint (pas utile dans notre cas) * @see Item */ void Item_Ope::paint(QPainter *pPainter, const QStyleOptionGraphicsItem */*option*/, QWidget */*widget*/) { this->GererSelection(pPainter) ; this->sTexte = this->pInstRepresentee->toString() ; //Définition du dégradé dans l'item qreal top (this->rect.top()) ; QPointF PremierPoint (0, top) ; QPointF SecondPoint (0, -top) ; QLinearGradient grad (PremierPoint, SecondPoint) ; QColor PremiereCouleur (0x98, 0xFE, 0x98, 0xFF) ; QColor SecondeCouleur (0x62, 0xBA, 0x62, 0xFF) ; grad.setColorAt(0, PremiereCouleur) ; grad.setColorAt(1, SecondeCouleur) ; //Définition du brush pour appliquer le dégradé QBrush brush (grad) ; //Dessin de l'item pPainter->setBrush(brush); pPainter->drawRect(rect); pPainter->setPen(QPen()); pPainter->drawText(rect, sTexte, QTextOption(Qt::AlignCenter)); }
void KisGradientBenchmark::benchmarkGradient() { KoColor fg(m_colorSpace); KoColor bg(m_colorSpace); fg.fromQColor(Qt::blue); bg.fromQColor(Qt::black); QBENCHMARK { QLinearGradient grad; grad.setColorAt(0, Qt::white); grad.setColorAt(1.0, Qt::red); KoAbstractGradient* kograd = KoStopGradient::fromQGradient(&grad); Q_ASSERT(kograd); KisGradientPainter fillPainter(m_device); //setupPainter(&fillPainter); fillPainter.setGradient(kograd); fillPainter.beginTransaction(kundo2_noi18n("Gradient Fill")); //fillPainter.setProgress(updater->startSubtask()); fillPainter.setOpacity(OPACITY_OPAQUE_U8); // default fillPainter.setCompositeOp(COMPOSITE_OVER); fillPainter.setGradientShape(KisGradientPainter::GradientShapeBiLinear); fillPainter.paintGradient(QPointF(0,0), QPointF(3000,3000), KisGradientPainter::GradientRepeatNone, true, false, 0, 0, GMP_IMAGE_WIDTH,GMP_IMAGE_HEIGHT); fillPainter.deleteTransaction(); } // uncomment this to see the output QImage out = m_device->convertToQImage(m_colorSpace->profile(),0,0,GMP_IMAGE_WIDTH,GMP_IMAGE_HEIGHT); out.save("fill_output.png"); }
/** * Décrit le façon de dessiner l'élément sur la scène * * @brief Item_Rout::paint(QPainter *pPainter, const QStyleOptionGraphicsItem * option, QWidget * widget) * @param pPainter le pinceau servant à dessiner sur la scène * @param option Option sur le dessin (pas utile dans notre cas) * @param widget Pointer vers le widget sur lequel l'item sera peint (pas utile dans notre cas) * @see Item */ void Item_Rout::paint(QPainter *pPainter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/) { this->GererSelection(pPainter) ; this->sTexte = this->pInstRepresentee->toString() ; //Définition du dégradé qreal top (this->rect.top()) ; qreal left (this->rect.left()) ; QPointF PremierPoint (0, top) ; QPointF SecondPoint (0, -top) ; QLinearGradient grad (PremierPoint, SecondPoint) ; QColor PremiereCouleur (0xFF, 0xD5, 0x98, 0xFF) ; QColor SecondeCouleur (0xF3, 0xA6, 0x62, 0xFF) ; grad.setColorAt(0, PremiereCouleur); grad.setColorAt(1, SecondeCouleur); //Définition du brush QBrush brush(grad); pPainter->setBrush(brush); //Dessin de l'item QPointF OriginePrem (left*(7.0/8.0), top) ; QPointF FinPrem (left*(7.0/8.0), -top) ; QPointF OrigineSec (-left*(7.0/8.0), top) ; QPointF FinSec (-left*(7.0/8.0), -top) ; pPainter->drawRect(rect); pPainter->drawLine(OriginePrem, FinPrem); pPainter->drawLine(OrigineSec, FinSec); pPainter->setPen(QPen()); pPainter->drawText(rect, sTexte, QTextOption(Qt::AlignCenter)); }
void PlaylistItemDelegate::paintActiveOverlay(QPainter *painter, const QRect &line) const { static QLinearGradient linearGradient; static bool initialized = false; if (!initialized) { QPalette palette; QColor highlightColor = palette.color(QPalette::Highlight); QColor backgroundColor = palette.color(QPalette::Base); const float animation = 0.4; const int gradientRange = 16; QColor color2 = QColor::fromHsv( highlightColor.hue(), (int) (backgroundColor.saturation() * (1.0f - animation) + highlightColor.saturation() * animation), (int) (backgroundColor.value() * (1.0f - animation) + highlightColor.value() * animation) ); QColor color1 = QColor::fromHsv( color2.hue(), qMax(color2.saturation() - gradientRange, 0), qMin(color2.value() + gradientRange, 255) ); linearGradient = QLinearGradient(0, 0, 0, THUMB_HEIGHT); linearGradient.setColorAt(0.0, color1); linearGradient.setColorAt(1.0, color2); initialized = true; } painter->fillRect(line, linearGradient); }
QLinearGradient* getLinearGradient(const CLLinearGradient* linear, const CLBoundingBox* bounds, const CLRenderResolver* resolver) { double x1 = bounds->getPosition().getX() + linear->getXPoint1().getAbsoluteValue() + (linear->getXPoint1().getRelativeValue() / 100.0 * bounds->getDimensions().getWidth()); double y1 = bounds->getPosition().getY() + linear->getYPoint1().getAbsoluteValue() + (linear->getYPoint1().getRelativeValue() / 100.0 * bounds->getDimensions().getHeight()); double x2 = bounds->getPosition().getX() + linear->getXPoint2().getAbsoluteValue() + (linear->getXPoint2().getRelativeValue() / 100.0 * bounds->getDimensions().getWidth()); double y2 = bounds->getPosition().getY() + linear->getYPoint2().getAbsoluteValue() + (linear->getYPoint2().getRelativeValue() / 100.0 * bounds->getDimensions().getHeight()); QLinearGradient* result = new QLinearGradient(x1, y1, x2, y2); switch (linear->getSpreadMethod()) { case CLGradientBase::REFLECT: result->setSpread(QGradient::ReflectSpread); break; case CLGradientBase::REPEAT: result->setSpread(QGradient::RepeatSpread); break; case CLGradientBase::PAD: result->setSpread(QGradient::PadSpread); break; default: break; } for (size_t i = 0; i < linear->getNumGradientStops(); ++i) { const CLGradientStop* stop = linear->getGradientStop(i); result->setColorAt(stop->getOffset().getAbsoluteValue() + stop->getOffset().getRelativeValue() / 100.0, getColor(stop->getStopColor(), resolver)); } return result; }
void Button::paintEvent(QPaintEvent *event) { QWidget::paintEvent(event); QPainter p(this); p.setRenderHint(QPainter::Antialiasing, true); QRect roundedRect(event->rect().x(), event->rect().y(), event->rect().width(), event->rect().height()); QPainterPath path(QPoint(roundedRect.left(), roundedRect.top() + d->topLeftRadius)); path.quadTo(roundedRect.left(), roundedRect.top(), roundedRect.left() + d->topLeftRadius, roundedRect.top()); path.lineTo(roundedRect.right() - d->topRightRadius, roundedRect.top()); path.quadTo(roundedRect.right(), roundedRect.top(), roundedRect.right(), roundedRect.top() + d->topRightRadius); path.lineTo(roundedRect.right(), roundedRect.bottom() - d->bottomRightRadius); path.quadTo(roundedRect.right(), roundedRect.bottom(), roundedRect.right() - d->bottomRightRadius, roundedRect.bottom()); path.lineTo(roundedRect.left() + d->bottomLeftRadius, roundedRect.bottom()); path.quadTo(roundedRect.left(), roundedRect.bottom(), roundedRect.left(), roundedRect.bottom() - d->bottomLeftRadius); path.closeSubpath(); QLinearGradient gradient; if(!d->pressed) { gradient = d->gradient; } if(d->pressed || (d->checked && d->checkable)) { gradient = d->pressedGradient; } if(!isEnabled()) { gradient = QLinearGradient(QPoint(0, 0), QPoint(0, height())); gradient.setColorAt(0, QColor(230, 230, 230)); gradient.setColorAt(1, QColor(200, 200, 200)); } gradient.setStart(QPoint(0, 0)); gradient.setFinalStop(QPoint(0, height())); p.fillPath(path, QBrush(gradient)); p.setPen(QColor(d->borderColor)); p.drawPath(path); p.setPen(QColor(d->textColor)); if(d->icon.isNull()) { if(d->checked && d->checkable && !d->checkedText.isEmpty()) p.drawText(roundedRect, Qt::AlignCenter, d->checkedText); if(!d->checkable || !d->checked || d->checkedText.isEmpty()) p.drawText(roundedRect, Qt::AlignCenter, d->text); } else { if(d->checked && d->checkable && !d->checkedIcon.isNull()) d->checkedIcon.paint(&p, roundedRect, Qt::AlignCenter); if(!d->checkable || !d->checked || d->checkedIcon.isNull()) d->icon.paint(&p, roundedRect.x()+4, roundedRect.y()+4, roundedRect.width()-8 , roundedRect.height()-8, Qt::AlignCenter); } }
void MainWindow::setupCustomPlot() { ui->customplot->xAxis->setRange(LEFTBOUND, RIGHTBOUND); ui->customplot->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom); ui->customplot->axisRect()->setRangeDrag(Qt::Horizontal | Qt::Vertical); //backgroundcolor QLinearGradient plotGrad; plotGrad.setStart(0,0); plotGrad.setFinalStop(0,350); plotGrad.setColorAt(0,QColor(80,80,80)); plotGrad.setColorAt(1,QColor(50,50,50)); ui->customplot->setBackground(plotGrad); // ui->customplot->xAxis->setBasePen(QPen(Qt::white, 1)); ui->customplot->yAxis->setBasePen(QPen(Qt::white, 1)); ui->customplot->xAxis->setTickPen(QPen(Qt::white, 1)); ui->customplot->yAxis->setTickPen(QPen(Qt::white, 1)); ui->customplot->xAxis->setSubTickPen(QPen(Qt::white, 1)); ui->customplot->yAxis->setSubTickPen(QPen(Qt::white, 1)); ui->customplot->xAxis->setTickLabelColor(Qt::white); ui->customplot->yAxis->setTickLabelColor(Qt::white); ui->customplot->xAxis->grid()->setPen(QPen(QColor(140,140,140), 1, Qt::DotLine)); ui->customplot->yAxis->grid()->setPen(QPen(QColor(140,140,140), 1, Qt::DotLine)); ui->customplot->xAxis->grid()->setSubGridPen(QPen(QColor(80,80,80), 1, Qt::DotLine)); ui->customplot->yAxis->grid()->setSubGridPen(QPen(QColor(80,80,80), 1, Qt::DotLine)); ui->customplot->xAxis->grid()->setSubGridVisible(true); ui->customplot->yAxis->grid()->setSubGridVisible(true); ui->customplot->xAxis->setLabelColor(Qt::white); ui->customplot->yAxis->setLabelColor(Qt::white); }
void DkTransferToolBar::loadSettings() { QSettings& settings = Settings::instance().getSettings(); settings.beginGroup("Pseudo Color"); int gSize = settings.beginReadArray("oldGradients"); for (int idx = 0; idx < gSize; idx++) { settings.setArrayIndex(idx); QVector<QGradientStop> stops; int sSize = settings.beginReadArray("gradient"); for (int sIdx = 0; sIdx < sSize; sIdx++) { settings.setArrayIndex(sIdx); QGradientStop s; s.first = settings.value("posRGBA", 0).toFloat(); s.second = QColor::fromRgba(settings.value("colorRGBA", QColor().rgba()).toInt()); qDebug() << "pos: " << s.first << " col: " << s.second; stops.append(s); } settings.endArray(); QLinearGradient g; g.setStops(stops); oldGradients.append(g); } settings.endArray(); settings.endGroup(); }
void QProg::paintBorder() { //int m_sizeW= 90; //int m_sizeH= 470; QPainter painter(this); painter.setWindow(0, 0, m_sizeW, m_sizeH); painter.setRenderHint(QPainter::Antialiasing); int m_linGradY = 40; //QLinearGradient linGrad(5, 40, 15, 40); // QLinearGradient linGrad(36, 5, 5, 15); QLinearGradient linGrad (40, m_sizeH-7, 40, m_sizeH-18); //QLinearGradient linGrad(m_sizeH, 5, m_sizeH, 15); linGrad.setColorAt(0, Qt::white); linGrad.setColorAt(1, Qt::black); linGrad.setSpread(QGradient::PadSpread); painter.setBrush(linGrad); QRectF border(5, 5, m_sizeW-10, m_sizeH-10); //QRectF border(0, 0, m_sizeW-10, m_sizeH); painter.drawRoundRect(border, 20, 5); // value rect painter.setBrush(QColor(70, 70, 70)); QRectF value(nValueRectX, nValueRectY, m_sizeW/1.3, m_sizeH/15); painter.drawRoundRect(value, 15); }
/** * Décrit le façon de dessiner l'élément sur la scène * * @brief Item_Tempo::paint(QPainter *pPainter, const QStyleOptionGraphicsItem * option, QWidget * widget) * @param pPainter le pinceau servant à dessiner sur la scène * @param option Option sur le dessin (pas utile dans notre cas) * @param widget Pointer vers le widget sur lequel l'item sera peint (pas utile dans notre cas) * @see Item */ void Item_Tempo::paint(QPainter *pPainter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/) { this->GererSelection(pPainter) ; this->sTexte = this->pInstRepresentee->toString() ; //Définition du dégradé qreal top (this->rect.top()) ; QPointF PremierPoint (0, top) ; QPointF SecondPoint (0, -top) ; QLinearGradient grad (PremierPoint, SecondPoint) ; QColor PremiereCouleur (0x5E, 0xC1, 0xFF, 0xFF) ; QColor SecondeCouleur (0x22, 0xAA, 0xFF, 0xFF) ; grad.setColorAt(0, PremiereCouleur) ; grad.setColorAt(1, SecondeCouleur) ; //Définition du brush QBrush brush(grad) ; pPainter->setBrush(brush) ; //Dessin de l'item qreal Rayon (-top) ; QPointF Centre (0, 0) ; QRectF RectTexte (top, top, -2*top, -2*top) ; pPainter->drawEllipse(Centre, Rayon, Rayon) ; pPainter->setPen(QPen()); pPainter->drawText(RectTexte, sTexte, QTextOption(Qt::AlignCenter)) ; }
//--------------------------------------------------------------- void LonLatGrid::drawLabel(QPainter &pnt, const Projection *proj, double value, int i, int j) { int a,b,c,d; QString label; QColor couleur(10,10,10); label = label.sprintf("%g", value); QPen penText(couleur); QFont fontText = Font::getFont(FONT_LonLatGridLabel); QFontMetrics fmet(fontText); QRect rect = fmet.boundingRect(label); pnt.setPen(penText); pnt.setFont(fontText); // use a gradient, because it's a bug sometimes with solid pattern (black background) QLinearGradient gradient; int r = 255; gradient.setColorAt(0, QColor(r,r,r, 170)); gradient.setColorAt(1, QColor(r,r,r, 170)); pnt.setBrush(gradient); //--------------------------------------------------------- // Ecrit le label //--------------------------------------------------------- // rect = fmet.boundingRect(label); // rect.moveTo((a+c)/2-rect.width()/2, (b+d)/2-rect.height()/2); // pnt.drawRect(rect.x()-1, rect.y(), rect.width()+2, fmet.ascent()+2); // pnt.drawText(rect, Qt::AlignHCenter|Qt::AlignVCenter, label); }
void SurfaceGraph::enableInterpModel(bool enable) { if (enable){ this->nn=n; this->mm=m; m_InterpSeries->setDrawMode(QSurface3DSeries::DrawSurfaceAndWireframe); m_InterpSeries->setFlatShadingEnabled(true); m_graph->axisX()->setLabelFormat("%.2f"); m_graph->axisZ()->setLabelFormat("%.2f"); m_graph->axisX()->setRange(xMin, xMax); m_graph->axisY()->setAutoAdjustRange(true); m_graph->axisZ()->setRange(zMin, zMax); m_graph->axisX()->setLabelAutoRotation(30); m_graph->axisY()->setLabelAutoRotation(90); m_graph->axisZ()->setLabelAutoRotation(30); m_graph->removeSeries(m_InterpSeries); m_graph->removeSeries(m_InitPlotSeries); m_graph->removeSeries(m_ResidSeries); m_graph->addSeries(m_InterpSeries); m_graph->activeTheme()->setType(Q3DTheme::ThemePrimaryColors); QLinearGradient gr; gr.setColorAt(0.0, Qt::green); m_graph->seriesList().at(0)->setBaseGradient(gr); m_graph->seriesList().at(0)->setColorStyle(Q3DTheme::ColorStyleRangeGradient); m_rangeMinX=xMin; m_rangeMinZ=zMin; m_stepX=(xMax-xMin)/double(skolkoX-1); m_stepZ=(zMax-zMin)/double(skolkoZ-1); kolichestvo=1; } }
void StylePainterMobile::drawProgress(const QRect& rect, double progress, bool leftToRight, bool animated, bool vertical) const { const int horizontalBorder = (vertical ? rect.width() / 4 : 0); const int verticalBorder = (vertical ? 0 : rect.height() / 4); const QRect targetRect = rect.adjusted(horizontalBorder, verticalBorder, -horizontalBorder, -verticalBorder); QPixmap result; QSize imageSize = sizeForPainterScale(targetRect); if (vertical) qSwap(imageSize.rheight(), imageSize.rwidth()); KeyIdentifier id; id.type = KeyIdentifier::Progress; id.width = imageSize.width(); id.height = imageSize.height(); id.trait1 = animated; id.trait2 = (!animated && !leftToRight); id.trait3 = progress * 100; if (!findCachedControl(id, &result)) { if (imageSize.isNull()) return; result = QPixmap(imageSize); result.fill(Qt::transparent); QPainter painter(&result); painter.setRenderHint(QPainter::Antialiasing); QRect progressRect(QPoint(0, 0), imageSize); qreal radius = radiusFactor * progressRect.height(); painter.setBrush(Qt::NoBrush); painter.setPen(borderPen()); progressRect.adjust(1, 1, -1, -1); painter.drawRoundedRect(progressRect, radius, radius); progressRect.adjust(1, 1, -1, -1); if (animated) { const int right = progressRect.right(); const int startPos = right * (1 - progressBarChunkPercentage) * 2 * fabs(progress - 0.5); progressRect.setWidth(progressBarChunkPercentage * right); progressRect.moveLeft(startPos); } else { progressRect.setWidth(progress * progressRect.width()); if (!leftToRight) progressRect.moveRight(imageSize.width() - 2); } if (progressRect.width() > 0) { QLinearGradient gradient; gradient.setStart(progressRect.bottomLeft()); gradient.setFinalStop(progressRect.topLeft()); gradient.setColorAt(0.0, highlightColor); gradient.setColorAt(1.0, highlightColor.lighter()); painter.setBrush(gradient); painter.setPen(Qt::NoPen); radius = radiusFactor * progressRect.height(); painter.drawRoundedRect(progressRect, radius, radius); } insertIntoCache(id, result); } QTransform transform; transform.rotate(-90); painter->drawPixmap(targetRect, vertical ? result.transformed(transform) : result); }
void AutoCompletionDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const { QStyledItemDelegate::paint(painter,option,index); const QString tag = index.data(Qt::UserRole).toString(); if (!tag.isEmpty()) { painter->save(); painter->setRenderHint(QPainter::Antialiasing, true); painter->setClipRect(option.rect); static bool init = false; static QFont f; static QLinearGradient g; if (!init) { f = painter->font(); f.setBold(true); f.setPointSize(f.pointSize()-1); g = QLinearGradient(QPointF(0, 0), QPointF(0, option.rect.height()-4)); QColor col = QApplication::palette().color(QPalette::Highlight); col.setAlpha(125); g.setColorAt(0, col); col.setAlpha(175); g.setColorAt(1, col); init = true; } static QFontMetrics m(f); static int height = m.height(); int rectHeight = option.rect.height(); int leftOver = (rectHeight-height); int padding = leftOver/2 >= 4 ? 2: 0; int topMargin = (leftOver-2*padding)/2; painter->setFont(f); const int width = m.width(tag); const int x = option.rect.x()+option.rect.width()-width-RIGHT_MARGIN-rectHeight/2; painter->setBrush(g); painter->setPen(Qt::NoPen); QRect rect(x, option.rect.y()+topMargin, width, height+2*padding); painter->drawRect(rect); painter->setClipRect(x-rectHeight/2,option.rect.y(),rectHeight/2,rectHeight); painter->drawEllipse(QRect( x-(height+2*padding)/2, option.rect.y()+topMargin, (height+2*padding), (height+2*padding))); painter->setClipRect(x+width,option.rect.y(),option.rect.height(),option.rect.height()); painter->drawEllipse(QRect( x+width-(height+2*padding)/2, option.rect.y()+topMargin, (height+2*padding), (height+2*padding))); painter->setPen(QApplication::palette().base().color()); painter->setClipping(false); painter->drawText(rect,Qt::AlignHCenter|Qt::AlignVCenter,tag); painter->restore(); } }
void QTMStyle::drawControl (ControlElement element, const QStyleOption* option, QPainter* painter, const QWidget* widget) const { switch (element) { #if 0 case CE_MenuItem: if (const QStyleOptionMenuItem *mi = qstyleoption_cast<const QStyleOptionMenuItem *> (option)) { QStyleOptionMenuItem mi2(*mi); mi2.text= QString ("pippo"); baseStyle()->drawControl (element, &mi2, painter, widget); break; } #endif case CE_ToolBar: { #ifdef UNIFIED_TOOLBAR if ((widget) && (widget->windowTitle() == "mode toolbar")) { // For unified tool bars, draw nothing. if (QMainWindow * mainWindow = qobject_cast<QMainWindow *>(widget->window())) { if ((mainWindow->unifiedTitleAndToolBarOnMac()) && (widget->parent()->objectName() != "central widget")) break; } //QColor mainWindowGradientBeginActive (150, 150, 150); //QColor mainWindowGradientBegin (200, 200, 200); //QColor mainWindowGradientEnd (232, 232, 232); QColor mainWindowGradientBeginActive (222, 222, 222); QColor mainWindowGradientEndActive (202, 202, 202); QColor mainWindowGradientBegin (236, 236, 236); QColor mainWindowGradientEnd (226, 226, 226); if (widget->window()->isActiveWindow()) mainWindowGradientBegin = mainWindowGradientBeginActive; if (widget->window()->isActiveWindow()) mainWindowGradientEnd = mainWindowGradientEndActive; // draw background gradient QLinearGradient linearGrad; if (option->state & State_Horizontal) linearGrad = QLinearGradient(0, option->rect.top(), 0, option->rect.bottom()); else linearGrad = QLinearGradient(option->rect.left(), 0, option->rect.right(), 0); linearGrad.setColorAt(0, mainWindowGradientBegin); linearGrad.setColorAt(1, mainWindowGradientEnd); painter->fillRect(option->rect, linearGrad); } #endif // UNIFIED_TOOLBAR } break; default: baseStyle()->drawControl (element, option, painter, widget); } }
void testShapedGradientPainterImpl(const QPolygonF &selectionPolygon, const QString &testName, const QPolygonF &selectionErasePolygon = QPolygonF()) { const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8(); KisPaintDeviceSP dev = new KisPaintDevice(cs); QRect imageRect(0,0,300,300); KisSelectionSP selection = new KisSelection(); KisPixelSelectionSP pixelSelection = selection->pixelSelection(); KisPainter selPainter(pixelSelection); selPainter.setFillStyle(KisPainter::FillStyleForegroundColor); selPainter.setPaintColor(KoColor(Qt::white, pixelSelection->colorSpace())); selPainter.paintPolygon(selectionPolygon); if (!selectionErasePolygon.isEmpty()) { selPainter.setCompositeOp(COMPOSITE_ERASE); selPainter.setPaintColor(KoColor(Qt::white, pixelSelection->colorSpace())); selPainter.paintPolygon(selectionErasePolygon); } selPainter.end(); pixelSelection->invalidateOutlineCache(); pixelSelection->convertToQImage(0, imageRect).save("sgt_selection.png"); QLinearGradient testGradient; testGradient.setColorAt(0.0, Qt::white); testGradient.setColorAt(0.5, Qt::green); testGradient.setColorAt(1.0, Qt::black); testGradient.setSpread(QGradient::ReflectSpread); QScopedPointer<KoStopGradient> gradient( KoStopGradient::fromQGradient(&testGradient)); KisGradientPainter gc(dev, selection); gc.setGradient(gradient.data()); gc.setGradientShape(KisGradientPainter::GradientShapePolygonal); gc.paintGradient(selectionPolygon.boundingRect().topLeft(), selectionPolygon.boundingRect().bottomRight(), KisGradientPainter::GradientRepeatNone, 0, false, imageRect.x(), imageRect.y(), imageRect.width(), imageRect.height()); QVERIFY(TestUtil::checkQImageExternal(dev->convertToQImage(0, imageRect), "shaped_gradient", "fill", testName, 1, 1, 0)); }
void DiagramSettings::Private::changeBackgroundColor() { if ( m_chart && m_chart->coordinatePlane() && m_chart->coordinatePlane()->diagram() ) { BackgroundAttributes bat = m_chart->coordinatePlane()->backgroundAttributes(); bat.setVisible( true ); ui->visibleBtn->setChecked( true ); if ( ui->color->isChecked() ) { QBrush setBrush = bat.brush(); const QColor color = QColorDialog::getColor( setBrush.color(), qq, tr( "Choose new color" ) ); if ( !color.isValid() ) return; bat.setBrush( color ); QPalette palette = ui->diagramBackground->palette(); palette.setBrush( QPalette::Button, color ); ui->diagramBackground->setPalette( palette ); } else if ( ui->textureBtn->isChecked() ) { //QBrush setBrush = m_chart->coordinatePlane()->diagram()->brush( index ); QImage texture; const QString filename = QFileDialog::getOpenFileName( qq, tr( "Choose Texture" ), QString(), tr( "Images (*.png *.xpm *.jpg)" ) ); if ( filename.isEmpty() ) return; texture = QImage( filename ); bat.setBrush( texture ); QPalette palette = ui->diagramBackground->palette(); palette.setBrush( QPalette::Button, QBrush( texture ) ); ui->diagramBackground->setPalette( palette ); } else { QBrush setBrush = bat.brush(); QGradient grad; QLinearGradient lGrad; lGrad.setColorAt( 0, Qt::black ); lGrad.setColorAt( 1, setBrush.color() ); grad = lGrad; if ( setBrush.gradient() ) grad = *setBrush.gradient(); const QGradient &color = GradientDialog::getGradient( grad, qq, tr( "Choose new color" ) ); bat.setBrush( color ); QPalette palette = ui->diagramBackground->palette(); palette.setBrush( QPalette::Button, QBrush( color ) ); ui->diagramBackground->setPalette( palette ); } bat.setVisible( true ); m_chart->coordinatePlane()->setBackgroundAttributes( bat ); qq->update(); } }
QGradient GradientDialog::gradient() const { QLinearGradient gradient; gradient.setStart( 0, 0 ); gradient.setStart( 1, 0 ); gradient.setCoordinateMode( QGradient::ObjectBoundingMode ); Q_FOREACH( const QGradientStop &stop, d->m_gradient ) gradient.setColorAt( stop.first, stop.second ); return gradient; }
Scene2D::Scene2D(Device* d, QObject* parent) : QGraphicsScene(parent) { d_ = d; myTextColor = Qt::black; //startTimer(100); QLinearGradient gradient = QLinearGradient(QPointF(), QPointF(5000, 5000)); gradient.setColorAt(0, QColor(45, 197, 255, 76)); gradient.setColorAt(1.0, QColor(0, 0, 0, 76)); //setBackgroundBrush(gradient); setBackgroundBrush(Qt::white); }
void KarbonGradientWidget::paintEvent(QPaintEvent*) { int w = width() - 4; // available width for gradient and points int h = height() - 7; // available height for gradient and points int ph = colorStopBorder_height + 2; // point marker height int gh = h - ph; // gradient area height QPainter painter(this); QLinearGradient gradient; gradient.setStart(QPointF(2, 2)); gradient.setFinalStop(QPointF(width() - 2, 2)); gradient.setStops(m_stops); m_checkerPainter.paint(painter, QRectF(2, 2, w, gh)); painter.setBrush(QBrush(gradient)); painter.drawRect(QRectF(2, 2, w, gh)); painter.setBrush(QBrush()); painter.setPen(palette().light().color()); // light frame around widget QRect frame(1, 1, width() - 2, height() - 2); painter.drawRect(frame); // light line between gradient and point area painter.drawLine(QLine(QPoint(1, 3 + gh), QPoint(width() - 1, 3 + gh))); painter.setPen(palette().dark().color()); // left-top frame around widget painter.drawLine(QPoint(), QPoint(0, height() - 1)); painter.drawLine(QPoint(), QPoint(width() - 1, 0)); // right-bottom from around gradient painter.drawLine(QPoint(width() - 2, 2), QPoint(width() - 2, 2 + gh)); painter.drawLine(QPoint(width() - 2, 2 + gh), QPoint(2, 2 + gh)); // upper line around point area painter.drawLine(QPoint(1, height() - 3 - ph), QPoint(width() - 1, height() - 3 - ph)); // right-bottom line around point area painter.drawLine(QPoint(width() - 2, height() - ph - 1), QPoint(width() - 2, height() - 2)); painter.drawLine(QPoint(width() - 2, height() - 2), QPoint(2, height() - 2)); m_pntArea.setRect(2, height() - ph - 2, w, ph); painter.fillRect(m_pntArea.x(), m_pntArea.y(), m_pntArea.width(), m_pntArea.height(), palette().window().color()); painter.setClipRect(m_pntArea.x(), m_pntArea.y(), m_pntArea.width(), m_pntArea.height()); painter.translate(m_pntArea.x(), m_pntArea.y()); foreach(const QGradientStop & stop, m_stops) paintColorStop(painter, (int)(stop.first * m_pntArea.width()), stop.second); }
void ScrollingContextualView::paintEvent(QPaintEvent *e) { Q_UNUSED(e); QPainter painter(this); QRect rect = visibleRegion().boundingRect(); QLinearGradient shadow; shadow.setFinalStop(0, 20); shadow.setColorAt(0, QColor(0x00, 0x00, 0x00, 48)); shadow.setColorAt(1, QColor(0x00, 0x00, 0x00, 0)); painter.fillRect(rect.x(), rect.y(), rect.width(), 20, QBrush(shadow)); }
void KoResourceItemDelegate::paint( QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index ) const { if( ! index.isValid() ) return; KoResource * resource = static_cast<KoResource*>( index.internalPointer() ); if (!resource) return; painter->save(); if (option.state & QStyle::State_Selected) painter->fillRect( option.rect, option.palette.highlight() ); QRect innerRect = option.rect.adjusted( 2, 1, -2, -1 ); KoAbstractGradient * gradient = dynamic_cast<KoAbstractGradient*>( resource ); if (gradient) { QGradient * g = gradient->toQGradient(); QLinearGradient paintGradient; paintGradient.setStops( g->stops() ); paintGradient.setStart( innerRect.topLeft() ); paintGradient.setFinalStop( innerRect.topRight() ); m_checkerPainter.paint( *painter, innerRect ); painter->fillRect( innerRect, QBrush( paintGradient ) ); delete g; } else { QImage thumbnail = index.data( Qt::DecorationRole ).value<QImage>(); QSize imageSize = thumbnail.size(); if(imageSize.height() > innerRect.height() || imageSize.width() > innerRect.width()) { qreal scaleW = static_cast<qreal>( innerRect.width() ) / static_cast<qreal>( imageSize.width() ); qreal scaleH = static_cast<qreal>( innerRect.height() ) / static_cast<qreal>( imageSize.height() ); qreal scale = qMin( scaleW, scaleH ); int thumbW = static_cast<int>( imageSize.width() * scale ); int thumbH = static_cast<int>( imageSize.height() * scale ); thumbnail = thumbnail.scaled( thumbW, thumbH, Qt::IgnoreAspectRatio, Qt::SmoothTransformation ); } painter->setRenderHint(QPainter::SmoothPixmapTransform, true); if (thumbnail.hasAlphaChannel()) { painter->fillRect(innerRect, Qt::white); // no checkers, they are confusing with patterns. } painter->fillRect( innerRect, QBrush(thumbnail) ); } painter->restore(); }
void GradientDialog::Private::updateGradientDisplay() { QLinearGradient gradient; gradient.setStart( 0, 0 ); gradient.setStart( 1, 0 ); gradient.setCoordinateMode( QGradient::ObjectBoundingMode ); Q_FOREACH( const QGradientStop &stop, m_gradient ) gradient.setColorAt( stop.first, stop.second ); QPalette palette = ui->gradientDisplay->palette(); palette.setBrush( QPalette::Background, gradient ); ui->gradientDisplay->setPalette( palette ); }
void SSlider::paintEvent(QPaintEvent*) { // This whole function is suboptimal QPainter painter(this); painter.setRenderHints(QPainter::Antialiasing); auto widthActual = ((width()-20-30)/maximum())*maximum(); mWidthActual = widthActual; auto xActual = 10+(width()-20-widthActual)/2; mXActual = xActual; auto jump = widthActual/maximum(); mJump = jump; auto xpos = (jump*value())+xActual; cursor = new QRectF(xpos,0,mControlSize,mControlSize); QRectF pilot(xActual,0, widthActual+mControlSize, mControlSize); painter.setPen(QPen(QColor("#161616"))); painter.setBrush(QBrush(QColor("#240128"))); painter.drawRoundedRect(pilot, mHalfWidth,mHalfWidth); QRectF highlight; auto startX = mStart*mJump+mXActual; if(xpos == startX) { highlight.setRect(0,0,0,0); } else if(xpos > startX) { highlight.setRect(startX,0, xpos+mControlSize-startX, mControlSize); } else { highlight.setRect(xpos,0, startX-(xpos)+mControlSize, mControlSize); } painter.setBrush(QBrush(QColor("#6E047C"))); QLinearGradient gradient; gradient.setStart(highlight.width() / 2, 0); gradient.setFinalStop(highlight.width() / 2, highlight.height()); gradient.setColorAt(0, "#B64FC4"); gradient.setColorAt(1, "#6E047C"); painter.setBrush(QBrush(gradient)); painter.drawRoundedRect(highlight, mHalfWidth,mHalfWidth); if(mGrabbed) { painter.setBrush(QBrush(QColor("#D24CE3"))); } else { painter.setBrush(QBrush(QColor("#8E06A0"))); } painter.setPen(QPen(QColor("#52015B"))); painter.drawEllipse(*cursor); painter.setPen(QPen(QColor("#B1B7E6"))); }
QLinearGradient KCategoryDrawer::linearG ( const QStyleOption &option, const QColor col ) const { QLinearGradient gradient = QLinearGradient(option.rect.topLeft(), option.rect.bottomRight()); gradient.setColorAt(option.direction == Qt::LeftToRight ? 0 : 1, col); gradient.setColorAt(option.direction == Qt::LeftToRight ? 1 : 0, Qt::transparent); return gradient; }
void InfoBar::resizeEvent( QResizeEvent* e ) { QWidget::resizeEvent( e ); QLinearGradient gradient = QLinearGradient( contentsRect().topLeft(), contentsRect().bottomRight() ); gradient.setColorAt( 0.0, QColor( 100, 100, 100 ) ); gradient.setColorAt( 1.0, QColor( 63, 63, 63 ) ); QPalette p = palette(); p.setBrush( QPalette::Window, QBrush( gradient ) ); setPalette( p ); }
void ContextPaneWidgetRectangle::onGradientClicked() { if (ui->colorGradient->isChecked()) { m_hasGradient = true; QLinearGradient gradient; QGradientStops stops; stops.append(QGradientStop(0, ui->colorColorButton->convertedColor())); stops.append(QGradientStop(1, Qt::white)); gradient.setStops(stops); ui->gradientLine->setEnabled(true); ui->gradientLine->setGradient(gradient); } }