QImage createRectGradient(int width, int height, const QGradient &gradient) { QImage::Format format = QImage::Format_ARGB32_Premultiplied; QImage buffer(width, height, format); buffer.fill( qRgba(255, 255,255, 255) ); QPainter painter(&buffer); painter.setPen(Qt::NoPen); painter.setRenderHint(QPainter::Antialiasing, true); painter.setCompositionMode(QPainter::CompositionMode_DestinationAtop); // Divide the rectangle into four triangles, each facing North, South, // East, and West. Every triangle will have its bounding box and linear // gradient. QLinearGradient linearGradient; // from center going North linearGradient = QLinearGradient(0, 0, width, height / 2); linearGradient.setStops( gradient.stops() ); linearGradient.setStart(width / 2, height / 2); linearGradient.setFinalStop(width / 2, 0); painter.setBrush(linearGradient); painter.drawRect(0, 0, width, height / 2); // from center going South linearGradient = QLinearGradient(0, 0, width, height / 2); linearGradient.setStops( gradient.stops() ); linearGradient.setStart(width / 2, height / 2); linearGradient.setFinalStop(width / 2, height); painter.setBrush(linearGradient); painter.drawRect(0, height / 2, width, height / 2); // clip the East and West portion QPainterPath clip; clip.moveTo(width, 0); clip.lineTo(width, height); clip.lineTo(0, 0); clip.lineTo(0, height); clip.closeSubpath(); painter.setClipPath(clip); // from center going East linearGradient = QLinearGradient(0, 0, width / 2, height); linearGradient.setStops( gradient.stops() ); linearGradient.setStart(width / 2, height / 2); linearGradient.setFinalStop(width, height / 2); painter.setBrush(linearGradient); painter.drawRect(width / 2, 0, width, height); // from center going West linearGradient = QLinearGradient(0, 0, width / 2, height); linearGradient.setStops( gradient.stops() ); linearGradient.setStart(width / 2, height / 2); linearGradient.setFinalStop(0, height / 2); painter.setBrush(linearGradient); painter.drawRect(0, 0, width / 2, height); painter.end(); return buffer; }
QGradient* KoStopGradient::toQGradient() const { QGradient* gradient; switch (type()) { case QGradient::LinearGradient: { gradient = new QLinearGradient(m_start, m_stop); break; } case QGradient::RadialGradient: { QPointF diff = m_stop - m_start; qreal radius = sqrt(diff.x() * diff.x() + diff.y() * diff.y()); gradient = new QRadialGradient(m_start, radius, m_focalPoint); break; } case QGradient::ConicalGradient: { qreal angle = atan2(m_start.y(), m_start.x()) * 180.0 / M_PI; if (angle < 0.0) angle += 360.0; gradient = new QConicalGradient(m_start, angle); break; } default: return 0; } QColor color; for (QList<KoGradientStop>::const_iterator i = m_stops.begin(); i != m_stops.end(); ++i) { i->second.toQColor(&color); gradient->setColorAt(i->first , color); } return gradient; }
void ShadowWindow::setGradientColor(QGradient& gradient) { gradient.setColorAt(0, QColor(0, 0, 0, 50)); gradient.setColorAt(0.2, QColor(0, 0, 0, IsActive_ ? 20 : 10)); gradient.setColorAt(0.6, IsActive_ ? QColor(0, 0, 0, 5) : Qt::transparent); gradient.setColorAt(1, Qt::transparent); }
void GradientRangeEditor::setGradient( const QGradient &g ) { gradientType = g.type(); stops = g.stops(); spreadType = g.spread(); switch( gradientType ) { case QGradient::LinearGradient: setStartPoint( ( ( QLinearGradient& )g ).start() ); setEndPoint( ( ( QLinearGradient& )g ).finalStop() ); break; case QGradient::RadialGradient: setStartPoint( ( ( QRadialGradient& )g ).center() ); setEndPoint( ( ( QRadialGradient& )g ).focalPoint() ); break; default: setStartPoint( ( ( QConicalGradient& )g ).center() ); qreal a = ( ( QConicalGradient& )g ).angle(); QLineF l( QLineF( 0.0, 0.0, 0.5, 0.0 ) * QMatrix().rotate( a ) ); l.translate( _startPoint ); setEndPoint( l.p2() ); break; } }
void KoResourcePopupAction::indexChanged(const QModelIndex &modelIndex) { if (! modelIndex.isValid()) { return; } d->menu->hide(); KoResource *resource = static_cast<KoResource*>(modelIndex.internalPointer()); if(resource) { KoAbstractGradient *gradient = dynamic_cast<KoAbstractGradient*>(resource); KoPattern *pattern = dynamic_cast<KoPattern*>(resource); if (gradient) { QGradient *qg = gradient->toQGradient(); qg->setCoordinateMode(QGradient::ObjectBoundingMode); d->background = QSharedPointer<KoShapeBackground>(new KoGradientBackground(qg)); } else if (pattern) { KoImageCollection *collection = new KoImageCollection(); d->background = QSharedPointer<KoShapeBackground>(new KoPatternBackground(collection)); qSharedPointerDynamicCast<KoPatternBackground>(d->background)->setPattern(pattern->pattern()); } emit resourceSelected(d->background); updateIcon(); } }
GLuint QOpenGL2GradientCache::getBuffer(const QGradient &gradient, qreal opacity) { quint64 hash_val = 0; QGradientStops stops = gradient.stops(); for (int i = 0; i < stops.size() && i <= 2; i++) hash_val += stops[i].second.rgba(); const QMutexLocker lock(&m_mutex); QOpenGLGradientColorTableHash::const_iterator it = cache.constFind(hash_val); if (it == cache.constEnd()) return addCacheElement(hash_val, gradient, opacity); else { do { const CacheInfo &cache_info = it.value(); if (cache_info.stops == stops && cache_info.opacity == opacity && cache_info.interpolationMode == gradient.interpolationMode()) { return cache_info.texId; } ++it; } while (it != cache.constEnd() && it.key() == hash_val); // an exact match for these stops and opacity was not found, create new cache return addCacheElement(hash_val, gradient, opacity); } }
QGradient GradientRangeEditor::gradient() const { QGradient g; switch( gradientType ) { case QGradient::LinearGradient: g = QLinearGradient( _startPoint, _endPoint ); break; case QGradient::RadialGradient: { QLineF l( _startPoint, _endPoint ); if( l.length() > 0.5 ) l.setLength( 0.5 - 0.001 ); g = QRadialGradient( l.p1(), 0.5, l.p2() ); break; } default: g = QConicalGradient( _startPoint, angle() ); break; } g.setStops( stops ); g.setSpread( spreadType ); return g; }
static PyObject *meth_QGradient_setColorAt(PyObject *sipSelf, PyObject *sipArgs) { PyObject *sipParseErr = NULL; { qreal a0; const QColor* a1; int a1State = 0; QGradient *sipCpp; if (sipParseArgs(&sipParseErr, sipArgs, "BdJ1", &sipSelf, sipType_QGradient, &sipCpp, &a0, sipType_QColor, &a1, &a1State)) { sipCpp->setColorAt(a0,*a1); sipReleaseType(const_cast<QColor *>(a1),sipType_QColor,a1State); Py_INCREF(Py_None); return Py_None; } } /* Raise an exception if the arguments couldn't be parsed. */ sipNoMethod(sipParseErr, sipName_QGradient, sipName_setColorAt, doc_QGradient_setColorAt); return NULL; }
void GradientRenderer::paint(QPainter *p) { QPolygonF pts = m_hoverPoints->points(); QGradient g; if (m_gradientType == Qt::LinearGradientPattern) { g = QLinearGradient(pts.at(0), pts.at(1)); } else if (m_gradientType == Qt::RadialGradientPattern) { g = QRadialGradient(pts.at(0), qMin(width(), height()) / 3.0, pts.at(1)); } else { QLineF l(pts.at(0), pts.at(1)); qreal angle = l.angle(QLineF(0, 0, 1, 0)); if (l.dy() > 0) angle = 360 - angle; g = QConicalGradient(pts.at(0), angle); } for (int i=0; i<m_stops.size(); ++i) g.setColorAt(m_stops.at(i).first, m_stops.at(i).second); g.setSpread(m_spread); p->setBrush(g); p->setPen(Qt::NoPen); p->drawRect(rect()); }
QPixmap QtGradientUtils::gradientPixmap(const QGradient &gradient, const QSize &size, bool checkeredBackground) { QImage image(size, QImage::Format_ARGB32); QPainter p(&image); p.setCompositionMode(QPainter::CompositionMode_Source); if (checkeredBackground) { int pixSize = 20; QPixmap pm(2 * pixSize, 2 * pixSize); QPainter pmp(&pm); pmp.fillRect(0, 0, pixSize, pixSize, Qt::lightGray); pmp.fillRect(pixSize, pixSize, pixSize, pixSize, Qt::lightGray); pmp.fillRect(0, pixSize, pixSize, pixSize, Qt::darkGray); pmp.fillRect(pixSize, 0, pixSize, pixSize, Qt::darkGray); p.setBrushOrigin((size.width() % pixSize + pixSize) / 2, (size.height() % pixSize + pixSize) / 2); p.fillRect(0, 0, size.width(), size.height(), pm); p.setBrushOrigin(0, 0); p.setCompositionMode(QPainter::CompositionMode_SourceOver); } const qreal scaleFactor = 0.999999; p.scale(scaleFactor, scaleFactor); QGradient grad = gradient; grad.setCoordinateMode(QGradient::StretchToDeviceMode); p.fillRect(QRect(0, 0, size.width(), size.height()), grad); p.drawRect(QRect(0, 0, size.width() - 1, size.height() - 1)); return QPixmap::fromImage(image); }
void KoGradientEditWidget::setGradient(const QGradient & gradient) { m_stops = gradient.stops(); m_type = gradient.type(); m_spread = gradient.spread(); updateUI(); }
QGradient* KarbonGradientHelper::convertGradient(const QGradient * gradient, QGradient::Type newType) { QPointF start, stop; // try to preserve gradient positions switch (gradient->type()) { case QGradient::LinearGradient: { const QLinearGradient *g = static_cast<const QLinearGradient*>(gradient); start = g->start(); stop = g->finalStop(); break; } case QGradient::RadialGradient: { const QRadialGradient *g = static_cast<const QRadialGradient*>(gradient); start = g->center(); stop = QPointF(g->radius(), 0.0); break; } case QGradient::ConicalGradient: { const QConicalGradient *g = static_cast<const QConicalGradient*>(gradient); start = g->center(); qreal radAngle = g->angle() * M_PI / 180.0; stop = QPointF(0.5 * cos(radAngle), 0.5 * sin(radAngle)); break; } default: start = QPointF(0.0, 0.0); stop = QPointF(0.5, 0.5); } QGradient *newGradient = 0; switch (newType) { case QGradient::LinearGradient: newGradient = new QLinearGradient(start, stop); break; case QGradient::RadialGradient: { QPointF diff(stop - start); qreal radius = sqrt(diff.x()*diff.x() + diff.y()*diff.y()); newGradient = new QRadialGradient(start, radius, start); break; } case QGradient::ConicalGradient: { QPointF diff(stop - start); qreal angle = atan2(diff.y(), diff.x()); if (angle < 0.0) angle += 2 * M_PI; newGradient = new QConicalGradient(start, angle * 180/M_PI); break; } default: return 0; } newGradient->setCoordinateMode(QGradient::ObjectBoundingMode); newGradient->setSpread(gradient->spread()); newGradient->setStops(gradient->stops()); return newGradient; }
void grSetup (sgradientParam prm,QGradient &g) { g.setColorAt(prm.pos1/100.,prm.color1); if(prm.pos2<=prm.pos1) return ; g.setColorAt(prm.pos2/100.,prm.color2); if(prm.pos3<=prm.pos2) return ; g.setColorAt(prm.pos3/100.,prm.color3); if(prm.pos4<=prm.pos3) return ; g.setColorAt(prm.pos4/100.,prm.color4); }
static QStringList styleSheetParameters(const QGradient &gradient) { QStringList result; if (gradient.type() != QGradient::ConicalGradient) { QString spread; switch (gradient.spread()) { case QGradient::PadSpread: spread = QLatin1String("pad"); break; case QGradient::ReflectSpread: spread = QLatin1String("reflect"); break; case QGradient::RepeatSpread: spread = QLatin1String("repeat"); break; default: qWarning() << "QtGradientUtils::styleSheetParameters(): gradient spread" << gradient.spread() << "not supported!"; break; } result << QLatin1String("spread:") + spread; } switch (gradient.type()) { case QGradient::LinearGradient: { const QLinearGradient *linearGradient = static_cast<const QLinearGradient*>(&gradient); result << QLatin1String("x1:") + QString::number(linearGradient->start().x()) << QLatin1String("y1:") + QString::number(linearGradient->start().y()) << QLatin1String("x2:") + QString::number(linearGradient->finalStop().x()) << QLatin1String("y2:") + QString::number(linearGradient->finalStop().y()); break; } case QGradient::RadialGradient: { const QRadialGradient *radialGradient = static_cast<const QRadialGradient*>(&gradient); result << QLatin1String("cx:") + QString::number(radialGradient->center().x()) << QLatin1String("cy:") + QString::number(radialGradient->center().y()) << QLatin1String("radius:") + QString::number(radialGradient->radius()) << QLatin1String("fx:") + QString::number(radialGradient->focalPoint().x()) << QLatin1String("fy:") + QString::number(radialGradient->focalPoint().y()); break; } case QGradient::ConicalGradient: { const QConicalGradient *conicalGradient = static_cast<const QConicalGradient*>(&gradient); result << QLatin1String("cx:") + QString::number(conicalGradient->center().x()) << QLatin1String("cy:") + QString::number(conicalGradient->center().y()) << QLatin1String("angle:") + QString::number(conicalGradient->angle()); break; } default: qWarning() << "QtGradientUtils::styleSheetParameters(): gradient type" << gradient.type() << "not supported!"; break; } return result; }
//TODO: Let GL generate the texture using an FBO void QOpenGL2GradientCache::generateGradientColorTable(const QGradient& gradient, uint *colorTable, int size, qreal opacity) const { int pos = 0; QGradientStops s = gradient.stops(); QVector<uint> colors(s.size()); for (int i = 0; i < s.size(); ++i) colors[i] = s[i].second.rgba(); // Qt LIES! It returns ARGB (on little-endian AND on big-endian) bool colorInterpolation = (gradient.interpolationMode() == QGradient::ColorInterpolation); uint alpha = qRound(opacity * 256); uint current_color = ARGB_COMBINE_ALPHA(colors[0], alpha); qreal incr = 1.0 / qreal(size); qreal fpos = 1.5 * incr; colorTable[pos++] = ARGB2RGBA(qPremultiply(current_color)); while (fpos <= s.first().first) { colorTable[pos] = colorTable[pos - 1]; pos++; fpos += incr; } if (colorInterpolation) current_color = qPremultiply(current_color); for (int i = 0; i < s.size() - 1; ++i) { qreal delta = 1/(s[i+1].first - s[i].first); uint next_color = ARGB_COMBINE_ALPHA(colors[i+1], alpha); if (colorInterpolation) next_color = qPremultiply(next_color); while (fpos < s[i+1].first && pos < size) { int dist = int(256 * ((fpos - s[i].first) * delta)); int idist = 256 - dist; if (colorInterpolation) colorTable[pos] = ARGB2RGBA(INTERPOLATE_PIXEL_256(current_color, idist, next_color, dist)); else colorTable[pos] = ARGB2RGBA(qPremultiply(INTERPOLATE_PIXEL_256(current_color, idist, next_color, dist))); ++pos; fpos += incr; } current_color = next_color; } Q_ASSERT(s.size() > 0); uint last_color = ARGB2RGBA(qPremultiply(ARGB_COMBINE_ALPHA(colors[s.size() - 1], alpha))); for (;pos < size; ++pos) colorTable[pos] = last_color; // Make sure the last color stop is represented at the end of the table colorTable[size-1] = last_color; }
bool SVGPaintServerGradient::setup(QPainter* painter, QPainterPath* painterPath, const RenderObject* object, SVGPaintTargetType type, bool isPaintingText) const { Q_UNUSED(isPaintingText); kDebug() << "!!!!!!!" << endl; m_ownerElement->buildGradient(); /*QPainter* painter(context ? context->platformContext() : 0); Q_ASSERT(painter);*/ /*QPainterPath* path(context ? context->currentPath() : 0); Q_ASSERT(path);*/ RenderStyle* renderStyle = object->style(); QGradient gradient = setupGradient(painter, painterPath, object); painter->setPen(Qt::NoPen); painter->setBrush(Qt::NoBrush); if (spreadMethod() == SPREADMETHOD_REPEAT) gradient.setSpread(QGradient::RepeatSpread); else if (spreadMethod() == SPREADMETHOD_REFLECT) gradient.setSpread(QGradient::ReflectSpread); else gradient.setSpread(QGradient::PadSpread); double opacity = 1.0; kDebug() << "type: " << type << (type & ApplyToFillTargetType) << endl; if ((type & ApplyToFillTargetType) && renderStyle->svgStyle()->hasFill()) { fillColorArray(gradient, gradientStops(), opacity); QBrush brush(gradient); brush.setMatrix(gradientTransform()); painter->setBrush(brush); /* FIXME khtml context->setFillRule(renderStyle->svgStyle()->fillRule());*/ } if ((type & ApplyToStrokeTargetType) && renderStyle->svgStyle()->hasStroke()) { fillColorArray(gradient, gradientStops(), opacity); QPen pen; QBrush brush(gradient); brush.setMatrix(gradientTransform()); setPenProperties(object, renderStyle, pen); pen.setBrush(brush); painter->setPen(pen); } return true; }
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 KTPaletteDocument::addGradient(const QGradient &gradient) { QDomElement element = createElement("Gradient"); element.setAttribute("type", gradient.type()); element.setAttribute("spread", gradient.spread()); const QGradient *gr = &gradient; switch (gradient.type()) { case QGradient::LinearGradient: { element.setAttribute("startX", static_cast<const QLinearGradient *>(gr)->start().x()); element.setAttribute("startY", static_cast<const QLinearGradient *>(gr)->start().y()); element.setAttribute("finalX", static_cast<const QLinearGradient *>(gr)->finalStop().x()); element.setAttribute("finalY", static_cast<const QLinearGradient *>(gr)->finalStop().y()); } break; case QGradient::RadialGradient: { element.setAttribute("centerX", static_cast<const QRadialGradient *>(gr)->center().x()); element.setAttribute("centerY", static_cast<const QRadialGradient *>(gr)->center().y()); element.setAttribute("focalX", static_cast<const QRadialGradient *>(gr)->focalPoint().x()); element.setAttribute("focalY", static_cast<const QRadialGradient *>(gr)->focalPoint().y()); element.setAttribute("radius", static_cast<const QRadialGradient *>(gr)->radius()); } break; case QGradient::ConicalGradient: { element.setAttribute("centerX", static_cast<const QRadialGradient *>(gr)->center().x()); element.setAttribute("centerY", static_cast<const QRadialGradient *>(gr)->center().y()); element.setAttribute("angle", static_cast<const QConicalGradient *>(gr)->angle()); } break; case QGradient::NoGradient: { } break; } QGradientStops stops = gradient.stops(); foreach (QGradientStop stop, stops) { QDomElement stopElement = createElement("Stop"); stopElement.setAttribute("value", stop.first); stopElement.setAttribute("colorName", stop.second.name()); stopElement.setAttribute("alpha", stop.second.alpha()); element.appendChild(stopElement); }
bool SVGPaintServerGradient::setup(GraphicsContext*& context, const RenderObject* object, SVGPaintTargetType type, bool isPaintingText) const { m_ownerElement->buildGradient(); QPainter* painter(context ? context->platformContext() : 0); Q_ASSERT(painter); QPainterPath* path(context ? context->currentPath() : 0); Q_ASSERT(path); const SVGRenderStyle* svgStyle = object->style()->svgStyle(); RenderStyle* style = object->style(); QGradient gradient = setupGradient(context, object); painter->setPen(Qt::NoPen); painter->setBrush(Qt::NoBrush); if (spreadMethod() == SpreadMethodRepeat) gradient.setSpread(QGradient::RepeatSpread); else if (spreadMethod() == SpreadMethodReflect) gradient.setSpread(QGradient::ReflectSpread); else gradient.setSpread(QGradient::PadSpread); double opacity = 1.0; if ((type & ApplyToFillTargetType) && svgStyle->hasFill()) { fillColorArray(gradient, gradientStops(), opacity); QBrush brush(gradient); brush.setMatrix(gradientTransform()); painter->setBrush(brush); context->setFillRule(svgStyle->fillRule()); } if ((type & ApplyToStrokeTargetType) && svgStyle->hasStroke()) { fillColorArray(gradient, gradientStops(), opacity); QPen pen; QBrush brush(gradient); brush.setMatrix(gradientTransform()); pen.setBrush(brush); painter->setPen(pen); applyStrokeStyleToContext(context, style, object); } return true; }
KoResourcePopupAction::KoResourcePopupAction(QSharedPointer<KoAbstractResourceServerAdapter>resourceAdapter, QObject *parent) : KAction(parent) , d(new Private()) { Q_ASSERT(resourceAdapter); d->menu = new QMenu(); QWidget *widget = new QWidget(d->menu); QWidgetAction *wdgAction = new QWidgetAction(widget); d->resourceList = new KoResourceItemView(widget); d->resourceList->setModel(new KoResourceModel(resourceAdapter, widget)); d->resourceList->setItemDelegate(new KoResourceItemDelegate(widget)); KoResourceModel * resourceModel = qobject_cast<KoResourceModel*>(d->resourceList->model()); if (resourceModel) { resourceModel->setColumnCount(1); } KoResource *resource = 0; if (resourceAdapter->resources().count() > 0) { resource = resourceAdapter->resources().at(0); } KoAbstractGradient *gradient = dynamic_cast<KoAbstractGradient*>(resource); KoPattern *pattern = dynamic_cast<KoPattern*>(resource); if (gradient) { QGradient *qg = gradient->toQGradient(); qg->setCoordinateMode(QGradient::ObjectBoundingMode); d->background = QSharedPointer<KoShapeBackground>(new KoGradientBackground(qg)); } else if (pattern) { KoImageCollection *collection = new KoImageCollection(); d->background = QSharedPointer<KoShapeBackground>(new KoPatternBackground(collection)); static_cast<KoPatternBackground*>(d->background.data())->setPattern(pattern->pattern()); } QHBoxLayout *layout = new QHBoxLayout(widget); layout->addWidget(d->resourceList); widget->setLayout(layout); wdgAction->setDefaultWidget(widget); d->menu->addAction(wdgAction); setMenu(d->menu); new QHBoxLayout(d->menu); d->menu->layout()->addWidget(widget); d->menu->layout()->setMargin(0); connect(d->resourceList, SIGNAL(clicked(QModelIndex)), this, SLOT(indexChanged(QModelIndex))); updateIcon(); }
static inline QGradient applySpreadMethod(QGradient gradient, GradientSpreadMethod spreadMethod) { switch (spreadMethod) { case SpreadMethodPad: gradient.setSpread(QGradient::PadSpread); break; case SpreadMethodReflect: gradient.setSpread(QGradient::ReflectSpread); break; case SpreadMethodRepeat: gradient.setSpread(QGradient::RepeatSpread); break; } return gradient; }
QPixmap PostEffect::progressivePixmap(const QPixmap &pm) { int maxSize = qMax( pm.width(),pm.height() ); float factor = (maxSize - 2 * progressiveBorderSize) / (float)maxSize; QGradient gradient; gradient.setColorAt( 1, QColor(0,0,0,0) ); gradient.setColorAt( factor, QColor(255,255,255,255) ); gradient.setColorAt( 0, QColor(255,255,255,255) ); QPixmap res = QPixmap::fromImage( createRectGradient(pm.width(),pm.height(), gradient) ); QPainter painter(&res); painter.setCompositionMode(QPainter::CompositionMode_SourceAtop); painter.drawPixmap(0,0,pm); painter.end(); return res; }
//----------------------------------------------------------------------------- //! //----------------------------------------------------------------------------- void tBoatWidget::DrawThrustArrow( QPainter& painter, int value, int yPos ) { painter.save(); painter.translate( QPointF(width()/2, yPos+0.5) ); int minValue = 10; int headLength = 24; int valuePix = value/2; if( valuePix < 0 ) valuePix = -valuePix; int s = (value > 0) ? 1 : -1; QColor arrowColor = (value > 0) ? QColor(0,188,0) : Qt::red; QColor grad1Color = QColor(7,131,255,255); QColor grad2Color = QColor(7,131,255,0); if( tSystemSettings::Instance()->NightMode() ) { arrowColor = arrowColor.darker(); grad1Color = grad1Color.darker(); } // Draw arrow QPainterPath path; path.moveTo( 0, -10 ); path.lineTo( s*(minValue + valuePix), -10); path.lineTo( s*(minValue + valuePix), -15 ); path.lineTo( s*(minValue + valuePix + headLength), 0 ); path.lineTo( s*(minValue + valuePix), 15 ); path.lineTo( s*(minValue + valuePix), 10 ); path.lineTo( 0, 10 ); painter.fillPath( path, arrowColor ); // Draw vacuum QGradient grad = QLinearGradient( QPointF(0,0), QPointF(-s*40,0) ); grad.setColorAt(0.0, grad1Color ); grad.setColorAt(1.0, grad2Color ); QPainterPath p2; p2.moveTo( 0, -12 ); p2.lineTo( -s*40, -21 ); p2.lineTo( -s*40, 21 ); p2.lineTo( 0, 12 ); painter.fillPath( p2, grad ); painter.restore(); }
void GradientDialog::setGradient( const QGradient &gradient ) { d->m_gradient.clear(); d->ui->stopSelector->clear(); const QGradientStops stops = gradient.stops(); Q_FOREACH( const QGradientStop &stop, stops ) { d->m_gradient.append( stop ); }
static PyObject *meth_QGradient_type(PyObject *sipSelf, PyObject *sipArgs) { PyObject *sipParseErr = NULL; { QGradient *sipCpp; if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGradient, &sipCpp)) { QGradient::Type sipRes; Py_BEGIN_ALLOW_THREADS sipRes = sipCpp->type(); Py_END_ALLOW_THREADS return sipConvertFromEnum(sipRes,sipType_QGradient_Type); } }
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; }
void MythYUVAPainter::DrawRect(const QRect &area, const QBrush &fillBrush, const QPen &linePen, int alpha) { QBrush brush(fillBrush); switch (fillBrush.style()) { case Qt::LinearGradientPattern: case Qt::RadialGradientPattern: case Qt::ConicalGradientPattern: { QGradient gradient = *fillBrush.gradient(); QGradientStops stops = gradient.stops(); for (QGradientStops::iterator it = stops.begin(); it != stops.end(); ++it) { it->second = rgb_to_yuv(it->second); it->second.setAlpha(alpha); } gradient.setStops(stops); brush = gradient; } break; default: brush.setColor(rgb_to_yuv(brush.color())); break; } QPen pen(linePen); pen.setColor(rgb_to_yuv(pen.color())); // We pull an image here, in the hopes that when DrawRect // pulls an image this will still be in the cache and have // the right properties. MythImage *im = GetImageFromRect(area, 0, 0, brush, pen); if (im) { im->SetToYUV(); im->DecrRef(); im = NULL; } MythQImagePainter::DrawRect(area, brush, pen, alpha); }
static QString styleSheetFillName(const QGradient &gradient) { QString result; switch (gradient.type()) { case QGradient::LinearGradient: result += QLatin1String("qlineargradient"); break; case QGradient::RadialGradient: result += QLatin1String("qradialgradient"); break; case QGradient::ConicalGradient: result += QLatin1String("qconicalgradient"); break; default: qWarning() << "QtGradientUtils::styleSheetFillName(): gradient type" << gradient.type() << "not supported!"; break; } return result; }
void QEmulationPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem) { if (state()->bgMode == Qt::OpaqueMode) { const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem); QRectF rect(p.x(), p.y() - ti.ascent.toReal(), ti.width.toReal(), (ti.ascent + ti.descent + 1).toReal()); fillBGRect(rect); } QPainterState *s = state(); Qt::BrushStyle style = qbrush_style(s->pen.brush()); if (style >= Qt::LinearGradientPattern && style <= Qt::ConicalGradientPattern) { QPen savedPen = s->pen; QGradient g = *s->pen.brush().gradient(); if (g.coordinateMode() > QGradient::LogicalMode) { QTransform mat = s->pen.brush().transform(); if (g.coordinateMode() == QGradient::StretchToDeviceMode) { mat.scale(real_engine->painter()->device()->width(), real_engine->painter()->device()->height()); } else if (g.coordinateMode() == QGradient::ObjectBoundingMode) { const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem); QRectF r(p.x(), p.y() - ti.ascent.toReal(), ti.width.toReal(), (ti.ascent + ti.descent + 1).toReal()); mat.translate(r.x(), r.y()); mat.scale(r.width(), r.height()); } g.setCoordinateMode(QGradient::LogicalMode); QBrush brush(g); brush.setTransform(mat); s->pen.setBrush(brush); penChanged(); real_engine->drawTextItem(p, textItem); s->pen = savedPen; penChanged(); return; } } real_engine->drawTextItem(p, textItem); }
QGradient* KarbonGradientHelper::defaultGradient(QGradient::Type type, QGradient::Spread spread, const QGradientStops &stops) { QGradient *gradient = 0; switch (type) { case QGradient::LinearGradient: gradient = new QLinearGradient(QPointF(0.0, 0.5), QPointF(1, 0.5)); break; case QGradient::RadialGradient: gradient = new QRadialGradient(QPointF(0.5, 0.5), sqrt(0.5)); break; case QGradient::ConicalGradient: gradient = new QConicalGradient(QPointF(0.5, 0.5), 0.0); break; default: return 0; } gradient->setCoordinateMode(QGradient::ObjectBoundingMode); gradient->setSpread(spread); gradient->setStops(stops); return gradient; }