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); } }
void TransferFunctionEditor::setColorMapStops( const QGradientStops& stops ) { QPolygonF redPoints, greenPoints, bluePoints, alphaPoints; const double redCMHt = _redWidget->height(); const double greenCMHt = _greenWidget->height(); const double blueCMHt = _blueWidget->height(); const double alphaCMHt = _alphaWidget->height(); for( int32_t i = 0; i < stops.size(); ++i ) { double position = stops.at( i ).first; QRgb color = stops.at( i ).second.rgba(); redPoints << QPointF( position * _redWidget->width(), redCMHt - qRed(color) * redCMHt / 255 ); greenPoints << QPointF( position * _greenWidget->width(), greenCMHt - qGreen(color) * greenCMHt / 255 ); bluePoints << QPointF( position * _blueWidget->width(), blueCMHt - qBlue(color) * blueCMHt / 255 ); alphaPoints << QPointF( position * _alphaWidget->width(), alphaCMHt - qAlpha(color) * alphaCMHt / 255 ); } _redWidget->setPoints( redPoints ); _greenWidget->setPoints( greenPoints ); _blueWidget->setPoints( bluePoints ); _alphaWidget->setPoints( alphaPoints ); }
WSOverlayScreenShotAnimation::WSOverlayScreenShotAnimation() { setVisible(false); const HostInfo& info = HostBase::instance()->getInfo(); int width = info.displayWidth; int height = info.displayHeight; setPos(width/2, height/2); int r = qMin(width, height); r = r/2; m_boundingRect = QRectF(-width/2, -height/2, width, height); m_gradient = QRadialGradient(0, 0, r, 0, 0); QGradientStops stops; stops.append(QGradientStop(0, QColor(0xFF,0xFF,0xFF,0xFF))); stops.append(QGradientStop(0.15, QColor(0xFF, 0xFF, 0xFF, 0xC0))); stops.append(QGradientStop(0.5, QColor(0xFF, 0xFF ,0xD0, 0xF0))); stops.append(QGradientStop(0.75, QColor(0xFF, 0xFF, 0xD0, 0x0F))); stops.append(QGradientStop(1.0, QColor(0xFF, 0xFF, 0xD0, 0x00))); m_gradient.setStops(stops); connect(WindowServer::instance(), SIGNAL(signalAboutToTakeScreenShot()), SLOT(stop())); connect(WindowServer::instance(), SIGNAL(signalTookScreenShot()), SLOT(start())); }
MythImage* MythPainter::GetImageFromRect(const QRect &area, int radius, int ellipse, const QBrush &fillBrush, const QPen &linePen) { if (area.width() <= 0 || area.height() <= 0) return NULL; uint64_t hash1 = ((0xfff & (uint64_t)area.width())) + ((0xfff & (uint64_t)area.height()) << 12) + ((0xff & (uint64_t)fillBrush.style()) << 24) + ((0xff & (uint64_t)linePen.width()) << 32) + ((0xff & (uint64_t)radius) << 40) + ((0xff & (uint64_t)linePen.style()) << 48) + ((0xff & (uint64_t)ellipse) << 56); uint64_t hash2 = ((0xffffffff & (uint64_t)linePen.color().rgba())) + ((0xffffffff & (uint64_t)fillBrush.color().rgba()) << 32); QString incoming("R"); if (fillBrush.style() == Qt::LinearGradientPattern && fillBrush.gradient()) { const QLinearGradient *gradient = static_cast<const QLinearGradient*>(fillBrush.gradient()); if (gradient) { incoming = QString::number( ((0xfff & (uint64_t)gradient->start().x())) + ((0xfff & (uint64_t)gradient->start().y()) << 12) + ((0xfff & (uint64_t)gradient->finalStop().x()) << 24) + ((0xfff & (uint64_t)gradient->finalStop().y()) << 36)); QGradientStops stops = gradient->stops(); for (int i = 0; i < stops.size(); i++) { incoming += QString::number( ((0xfff * (uint64_t)(stops[i].first * 100))) + ((uint64_t)stops[i].second.rgba() << 12)); } } } incoming += QString::number(hash1) + QString::number(hash2); if (m_StringToImageMap.contains(incoming)) { m_StringExpireList.remove(incoming); m_StringExpireList.push_back(incoming); return m_StringToImageMap[incoming]; } MythImage *im = GetFormatImage(); if (im) { DrawRectPriv(im, area, radius, ellipse, fillBrush, linePen); m_SoftwareCacheSize += (im->bytesPerLine() * im->height()); m_StringToImageMap[incoming] = im; m_StringExpireList.push_back(incoming); ExpireImages(m_MaxSoftwareCacheSize); } return im; }
void updateGradient() { static const double n_colors = 6; QGradientStops colors; colors.reserve(n_colors+1); for ( int i = 0; i <= n_colors; ++i ) colors.append(QGradientStop(i/n_colors, QColor::fromHsvF(i/n_colors, saturation, value))); w->setColors(colors); }
QGradientStops QQuickGradient::gradientStops() const { QGradientStops stops; for (int i = 0; i < m_stops.size(); ++i){ int j = 0; while (j < stops.size() && stops.at(j).first < m_stops[i]->position()) j++; stops.insert(j, QGradientStop(m_stops.at(i)->position(), m_stops.at(i)->color())); } return stops; }
QRadialGradient ControlSlider::backgroundGradient() { QRadialGradient gradient(0.5,0.5,1.0,0.5,0.5); gradient.setCoordinateMode(QGradient::ObjectBoundingMode); QGradientStops stops; stops.append(QPair<qreal,QColor>(0.0, Qt::white)); stops.append(QPair<qreal,QColor>(0.8, backgroundColor())); stops.append(QPair<qreal,QColor>(1.0, Qt::white)); gradient.setStops(stops); return gradient; }
QGradientStops QQuickPathGradient::sortedGradientStops() const { QGradientStops result; for (int i = 0; i < m_stops.count(); ++i) { QQuickPathGradientStop *s = static_cast<QQuickPathGradientStop *>(m_stops[i]); int j = 0; while (j < result.count() && result[j].first < s->position()) ++j; result.insert(j, QGradientStop(s->position(), s->color())); } return result; }
void ColorMapWidget::setGradientStops( const QGradientStops& stops ) { if( _channel != lexis::render::ColorMap::Channel::alpha ) return; _gradient = QLinearGradient( 0.0f, 0.0f, width(), 0.0f ); for( int i = 0; i < stops.size(); ++i ) _gradient.setColorAt( stops.at( i ).first, stops.at( i ).second ); _background = QImage(); _generateBackground(); }
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); } }
void GradientLine::updateGradient() { if (m_useGradient) { QGradientStops stops; for (int i = 0; i < m_stops.size(); i++) { stops.append(QPair<qreal, QColor>(m_stops.at(i), m_colorList.at(i))); } m_gradient.setStops(stops); } else { if (!active()) return; } }
void SvgStyleParser::parseColorStops(QGradient *gradient, const KoXmlElement &e) { QGradientStops stops; QColor c; for (KoXmlNode n = e.firstChild(); !n.isNull(); n = n.nextSibling()) { KoXmlElement stop = n.toElement(); if (stop.tagName() == "stop") { float offset; QString temp = stop.attribute("offset"); if (temp.contains('%')) { temp = temp.left(temp.length() - 1); offset = temp.toFloat() / 100.0; } else offset = temp.toFloat(); QString stopColorStr = stop.attribute("stop-color"); if (!stopColorStr.isEmpty()) { if (stopColorStr == "inherit") { stopColorStr = inheritedAttribute("stop-color", stop); } parseColor(c, stopColorStr); } else { // try style attr QString style = stop.attribute("style").simplified(); QStringList substyles = style.split(';', QString::SkipEmptyParts); for (QStringList::Iterator it = substyles.begin(); it != substyles.end(); ++it) { QStringList substyle = it->split(':'); QString command = substyle[0].trimmed(); QString params = substyle[1].trimmed(); if (command == "stop-color") parseColor(c, params); if (command == "stop-opacity") c.setAlphaF(params.toDouble()); } } QString opacityStr = stop.attribute("stop-opacity"); if (!opacityStr.isEmpty()) { if (opacityStr == "inherit") { opacityStr = inheritedAttribute("stop-opacity", stop); } c.setAlphaF(opacityStr.toDouble()); } stops.append(QPair<qreal, QColor>(offset, c)); } } if (stops.count()) gradient->setStops(stops); }
void ColorTemplatePlot::handleColorChange(const QVector<QPointF> &points) { double minValue = parentWidget()->mXInterval.minValue(); double maxValue = parentWidget()->mXInterval.maxValue(); QGradientStops stops; foreach (const QPointF &p, points) { double x = (p.x() - minValue)/(maxValue - minValue); if (x < 0.0) x = 0.0; if (x > 1.0) x = 1.0; stops.push_back(QPair<qreal, QColor>(x, parentWidget()->mColorData.color(minValue, maxValue, p.x()))); }
Ui::ShadowedWidget<__Base>::ShadowedWidget(QWidget* _parent, int _tailLen, double _alphaFrom, double _alphaTo) : __Base(_parent) , tailLenPx_(_tailLen) { QGradientStops stops; QColor voipShadowColor("#000000"); voipShadowColor.setAlphaF(_alphaFrom); stops.append(qMakePair(0.0f, voipShadowColor)); voipShadowColor.setAlphaF(_alphaTo); stops.append(qMakePair(1.0f, voipShadowColor)); linearGradient_.setStops(stops); }
void ShadeWidget::setGradientStops(const QGradientStops &stops) { if (m_shade_type == ARGBShade) { m_alpha_gradient = QLinearGradient(0, 0, width(), 0); for (int i=0; i<stops.size(); ++i) { QColor c = stops.at(i).second; m_alpha_gradient.setColorAt(stops.at(i).first, QColor(c.red(), c.green(), c.blue())); } m_shade = QImage(); generateShade(); update(); } }
//----------------------------------------------------------------------------- void HeaderItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget) { Q_UNUSED(option); Q_UNUSED(widget); painter->setRenderHint(QPainter::Antialiasing); QFont font = painter->font(); font.setBold(true); font.setPointSize(static_cast<int>(font.pointSize() * 1.4)); painter->setFont(font); QRectF frame(QPoint(0, 0), geometry().size()); // paint the background QGradientStops stops; stops.append(QGradientStop(0.0, QColor(40, 57, 74))); stops.append(QGradientStop(0.5, QColor(0, 0, 0))); stops.append(QGradientStop(1.0, QColor(10, 16, 23))); QLinearGradient gradient(frame.topLeft(), frame.bottomLeft()); gradient.setStops(stops); painter->setPen(QColor(56, 73, 93)); painter->setBrush(QBrush(gradient)); QPainterPath path; path.moveTo(0, 20); path.arcTo(0, 0, 40, 40, 180, -90); path.lineTo(frame.right() - 20, 0); path.arcTo(frame.right() - 40, 0, 40, 40, 90, -90); path.lineTo(frame.right(), frame.bottom()); path.lineTo(0, frame.bottom()); path.lineTo(0, 20); path.closeSubpath(); painter->drawPath(path); painter->setPen(Qt::white); painter->drawText(frame, Qt::AlignCenter, title); }
QSGNode *QQuickRectangle::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *data) { Q_UNUSED(data); Q_D(QQuickRectangle); if (width() <= 0 || height() <= 0 || (d->color.alpha() == 0 && (!d->pen || d->pen->width() == 0 || d->pen->color().alpha() == 0))) { delete oldNode; return 0; } QSGRectangleNode *rectangle = static_cast<QSGRectangleNode *>(oldNode); if (!rectangle) rectangle = d->sceneGraphContext()->createRectangleNode(); rectangle->setRect(QRectF(0, 0, width(), height())); rectangle->setColor(d->color); if (d->pen && d->pen->isValid()) { rectangle->setPenColor(d->pen->color()); rectangle->setPenWidth(d->pen->width()); rectangle->setAligned(d->pen->pixelAligned()); } else { rectangle->setPenWidth(0); } rectangle->setRadius(d->radius); rectangle->setAntialiasing(d->antialiasing); QGradientStops stops; if (d->gradient) { QList<QQuickGradientStop *> qxstops = d->gradient->m_stops; for (int i = 0; i < qxstops.size(); ++i){ int j = 0; while (j < stops.size() && stops.at(j).first < qxstops[i]->position()) j++; stops.insert(j, QGradientStop(qxstops.at(i)->position(), qxstops.at(i)->color())); } } rectangle->setGradientStops(stops); rectangle->update(); return rectangle; }
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); }
void TupGradientSelector::setStops(const QGradientStops &stops) { m_gradient.setStops(stops); m_arrows.clear(); for (int i = 0; i < stops.count(); i++) addArrow(calcArrowPos((int) (100 - (stops[i].first * 100)) ), stops[i].second); update(); }
bool GradientStopEditor::setStops( const QGradientStops &s ) { int countStops = s.size(); if( countStops < 2 ) return false; values.clear(); positions.clear(); switch( stopChannel ) { case redChannel: for( int i = 0; i < countStops; i++ ) { positions << s[ i ].first; values << s[ i ].second.red(); } break; case greenChannel: for( int i = 0; i < countStops; i++ ) { positions << s[ i ].first; values << s[ i ].second.green(); } break; case blueChannel: for( int i = 0; i < countStops; i++ ) { positions << s[ i ].first; values << s[ i ].second.blue(); } break; case composite: for( int i = 0; i < countStops; i++ ) { positions << s[ i ].first; values << s[ i ].second.alpha(); } break; } if( positions[ 0 ] != 0.0 ) positions[ 0 ] = 0.0; if( positions[ countStops - 1 ] != 1.0 ) positions[ countStops - 1 ] = 1.0; generateBackground( true ); update(); return true; }
//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; }
//! [1] void LayoutItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget /*= 0*/) { Q_UNUSED(widget); Q_UNUSED(option); QRectF frame(QPointF(0,0), geometry().size()); qreal w = m_pix->width(); qreal h = m_pix->height(); QGradientStops stops; //! [1] //! [2] // paint a background rect (with gradient) QLinearGradient gradient(frame.topLeft(), frame.topLeft() + QPointF(200,200)); stops << QGradientStop(0.0, QColor(60, 60, 60)); stops << QGradientStop(frame.height()/2/frame.height(), QColor(102, 176, 54)); //stops << QGradientStop(((frame.height() + h)/2 )/frame.height(), QColor(157, 195, 55)); stops << QGradientStop(1.0, QColor(215, 215, 215)); gradient.setStops(stops); painter->setBrush(QBrush(gradient)); painter->drawRoundedRect(frame, 10.0, 10.0); // paint a rect around the pixmap (with gradient) QPointF pixpos = frame.center() - (QPointF(w, h)/2); QRectF innerFrame(pixpos, QSizeF(w, h)); innerFrame.adjust(-4, -4, +4, +4); gradient.setStart(innerFrame.topLeft()); gradient.setFinalStop(innerFrame.bottomRight()); stops.clear(); stops << QGradientStop(0.0, QColor(215, 255, 200)); stops << QGradientStop(0.5, QColor(102, 176, 54)); stops << QGradientStop(1.0, QColor(0, 0, 0)); gradient.setStops(stops); painter->setBrush(QBrush(gradient)); painter->drawRoundedRect(innerFrame, 10.0, 10.0); painter->drawPixmap(pixpos, *m_pix); }
void GradientSliderWidget::SetGradientStops(QGradientStops newStops) { QList<uint> keys = sliders.keys(); for (int i=0; i<keys.size(); ++i) { RemoveSlider(keys[i]); } if (newStops.size() >= 2) { for (int i=0; i<newStops.size(); ++i) { unsigned int newSlider = AddSlider(); SetSliderValue(newSlider, minValue + (1.0-newStops[i].first) * (maxValue-minValue)); SetSliderColor(newSlider, newStops[i].second); } } else { CreateDefaultSliders(); } UpdateGradientStops(); }
QColor KarbonGradientHelper::colorAt(qreal position, const QGradientStops &stops) { if (! stops.count()) return QColor(); if (stops.count() == 1) return stops.first().second; QGradientStop prevStop(-1.0, QColor()); QGradientStop nextStop(2.0, QColor()); // find framing gradient stops foreach(const QGradientStop & stop, stops) { if (stop.first > prevStop.first && stop.first < position) prevStop = stop; if (stop.first < nextStop.first && stop.first > position) nextStop = stop; } QColor theColor; if (prevStop.first < 0.0) { // new stop is before the first stop theColor = nextStop.second; } else if (nextStop.first > 1.0) { // new stop is after the last stop theColor = prevStop.second; } else { // linear interpolate colors between framing stops QColor prevColor = prevStop.second, nextColor = nextStop.second; qreal colorScale = (position - prevStop.first) / (nextStop.first - prevStop.first); theColor.setRedF(prevColor.redF() + colorScale *(nextColor.redF() - prevColor.redF())); theColor.setGreenF(prevColor.greenF() + colorScale *(nextColor.greenF() - prevColor.greenF())); theColor.setBlueF(prevColor.blueF() + colorScale *(nextColor.blueF() - prevColor.blueF())); theColor.setAlphaF(prevColor.alphaF() + colorScale *(nextColor.alphaF() - prevColor.alphaF())); } return theColor; }
QGradientStops MeshGenerator::resampleGradientStops(QGradientStops stops) { QColor colorMap[256]; int startj, endj; for(int i=0; i<stops.size(); i++) { float pos = stops[i].first; QColor color = stops[i].second; endj = pos*255; colorMap[endj] = color; if (i > 0) { QColor colStart, colEnd; colStart = colorMap[startj]; colEnd = colorMap[endj]; float rb,gb,bb,ab, re,ge,be,ae; rb = colStart.red(); gb = colStart.green(); bb = colStart.blue(); ab = colStart.alpha(); re = colEnd.red(); ge = colEnd.green(); be = colEnd.blue(); ae = colEnd.alpha(); for (int j=startj+1; j<endj; j++) { float frc = (float)(j-startj)/(float)(endj-startj); float r,g,b,a; r = rb + frc*(re-rb); g = gb + frc*(ge-gb); b = bb + frc*(be-bb); a = ab + frc*(ae-ab); colorMap[j] = QColor(r, g, b, a); } } startj = endj; } QGradientStops newStops; for (int i=0; i<256; i++) { float pos = (float)i/255.0f; newStops << QGradientStop(pos, colorMap[i]); } return newStops; }
void GradientEditor::setGradientStops(const QGradientStops &stops) { QPolygonF pts_red, pts_green, pts_blue, pts_alpha; qreal h_red = m_red_shade->height(); qreal h_green = m_green_shade->height(); qreal h_blue = m_blue_shade->height(); qreal h_alpha = m_alpha_shade->height(); for (int i=0; i<stops.size(); ++i) { qreal pos = stops.at(i).first; QRgb color = stops.at(i).second.rgba(); pts_red << QPointF(pos * m_red_shade->width(), h_red - qRed(color) * h_red / 255); pts_green << QPointF(pos * m_green_shade->width(), h_green - qGreen(color) * h_green / 255); pts_blue << QPointF(pos * m_blue_shade->width(), h_blue - qBlue(color) * h_blue / 255); pts_alpha << QPointF(pos * m_alpha_shade->width(), h_alpha - qAlpha(color) * h_alpha / 255); } set_shade_points(pts_red, m_red_shade); set_shade_points(pts_green, m_green_shade); set_shade_points(pts_blue, m_blue_shade); set_shade_points(pts_alpha, m_alpha_shade); }
bool GradientStopsEditor::setStops( const QGradientStops &s ) { int countStops = s.size(); if( countStops < 2 ) return false; bool oldValueOfHandleSignals = handleSignals; handleSignals = false; r.setStops( s ); g.setStops( s ); b.setStops( s ); c.setStops( s ); c.setCompositeGradientStops( s ); handleSignals = oldValueOfHandleSignals; emit stopsChanged( s ); return true; }
void GradientStopEditor::setCompositeGradientStops( const QGradientStops &s ) { if( stopChannel == composite ) { compositeGradient = QLinearGradient( 0, 0, width(), 0 ); QGradientStops newStops; int countStops = s.size(); for( int i = 0; i < countStops; i++ ) { QColor c( s[ i ].second ); c.setAlpha( 255 ); newStops << QGradientStop( s[ i ].first, c ); } //newStops << compositeGradient.stops(); compositeGradient.setStops( newStops ); generateBackground( true ); update(); } }
bool PathGroups::keyPressEvent(QKeyEvent *event) { for(int i=0; i<m_paths.count(); i++) { if (m_paths[i]->grabsMouse()) { if (event->key() == Qt::Key_G) { m_paths[i]->removeFromMouseGrabberPool(); return true; } if (event->key() == Qt::Key_C) { bool b = m_paths[i]->closed(); m_paths[i]->setClosed(!b); return true; } else if (event->key() == Qt::Key_P) { bool b = m_paths[i]->showPoints(); m_paths[i]->setShowPoints(!b); return true; } else if (event->key() == Qt::Key_L) { bool b = m_paths[i]->showLength(); m_paths[i]->setShowLength(!b); return true; } else if (event->key() == Qt::Key_X) { m_paths[i]->setMoveAxis(PathGroupGrabber::MoveX); return true; } else if (event->key() == Qt::Key_Y) { if (event->modifiers() & Qt::ControlModifier || event->modifiers() & Qt::MetaModifier) m_paths[i]->redo(); else m_paths[i]->setMoveAxis(PathGroupGrabber::MoveY); return true; } else if (event->key() == Qt::Key_Z) { if (event->modifiers() & Qt::ControlModifier || event->modifiers() & Qt::MetaModifier) m_paths[i]->undo(); else m_paths[i]->setMoveAxis(PathGroupGrabber::MoveZ); return true; } else if (event->key() == Qt::Key_W) { m_paths[i]->setMoveAxis(PathGroupGrabber::MoveAll); return true; } else if (event->key() == Qt::Key_S) { int idx = m_paths[i]->pointPressed(); if (idx > -1) { float radx = m_paths[i]->getRadX(idx); if (event->modifiers() & Qt::ShiftModifier) radx--; else radx++; radx = qMax(1.0f, radx); m_paths[i]->setRadX(idx, radx, m_sameForAll); return true; } } else if (event->key() == Qt::Key_T) { int idx = m_paths[i]->pointPressed(); if (idx > -1) { float rady = m_paths[i]->getRadY(idx); if (event->modifiers() & Qt::ShiftModifier) rady--; else rady++; rady = qMax(1.0f, rady); m_paths[i]->setRadY(idx, rady, m_sameForAll); } else // switch to tube mode { if (event->modifiers() & Qt::ShiftModifier) { m_paths[i]->loadCaption(); } else { bool b = m_paths[i]->tube(); m_paths[i]->setTube(!b); } } return true; } else if (event->key() == Qt::Key_A) { int idx = m_paths[i]->pointPressed(); if (idx > -1) { float a = m_paths[i]->getAngle(idx); if (event->modifiers() & Qt::ShiftModifier) a--; else a++; m_paths[i]->setAngle(idx, a, m_sameForAll); return true; } } else if (event->key() == Qt::Key_Delete || event->key() == Qt::Key_Backspace || event->key() == Qt::Key_Backtab) { m_paths[i]->removeFromMouseGrabberPool(); m_paths.removeAt(i); return true; } if (event->key() == Qt::Key_Space) { PropertyEditor propertyEditor; QMap<QString, QVariantList> plist; QVariantList vlist; vlist.clear(); vlist << QVariant("double"); vlist << QVariant(m_paths[i]->opacity()); vlist << QVariant(0.0); vlist << QVariant(1.0); vlist << QVariant(0.1); // singlestep vlist << QVariant(1); // decimals plist["opacity"] = vlist; vlist.clear(); vlist << QVariant("colorgradient"); QGradientStops stops = m_paths[i]->stops(); for(int s=0; s<stops.size(); s++) { float pos = stops[s].first; QColor color = stops[s].second; int r = color.red(); int g = color.green(); int b = color.blue(); int a = color.alpha(); vlist << QVariant(pos); vlist << QVariant(r); vlist << QVariant(g); vlist << QVariant(b); vlist << QVariant(a); } plist["color"] = vlist; vlist.clear(); vlist << QVariant("checkbox"); vlist << QVariant(m_paths[i]->filterPathLen()); plist["filter on length"] = vlist; float vmin, vmax; m_paths[i]->userPathlenMinmax(vmin, vmax); vlist.clear(); vlist << QVariant("string"); vlist << QVariant(QString("%1 %2").arg(vmin).arg(vmax)); plist["length bounds"] = vlist; vlist.clear(); vlist << QVariant("checkbox"); vlist << QVariant(m_paths[i]->scaleType()); plist["scale type"] = vlist; vlist.clear(); vlist << QVariant("checkbox"); vlist << QVariant(m_paths[i]->depthcue()); plist["depthcue"] = vlist; vlist.clear(); vlist << QVariant("int"); vlist << QVariant(m_paths[i]->segments()); vlist << QVariant(1); vlist << QVariant(100); plist["smoothness"] = vlist; vlist.clear(); vlist << QVariant("int"); vlist << QVariant(m_paths[i]->sections()); vlist << QVariant(1); vlist << QVariant(100); plist["sections"] = vlist; vlist.clear(); vlist << QVariant("int"); vlist << QVariant(m_paths[i]->sparseness()); vlist << QVariant(1); vlist << QVariant(100); plist["sparseness"] = vlist; vlist.clear(); vlist << QVariant("int"); vlist << QVariant(m_paths[i]->separation()); vlist << QVariant(0); vlist << QVariant(10); plist["screen separation"] = vlist; vlist.clear(); vlist << QVariant("combobox"); vlist << QVariant(m_paths[i]->capType()); vlist << QVariant("flat"); vlist << QVariant("round"); vlist << QVariant("arrow"); plist["cap style"] = vlist; vlist.clear(); vlist << QVariant("combobox"); vlist << QVariant(m_paths[i]->arrowDirection()); vlist << QVariant("forward"); vlist << QVariant("backward"); plist["arrow direction"] = vlist; vlist.clear(); vlist << QVariant("checkbox"); vlist << QVariant(m_paths[i]->animate()); plist["animate"] = vlist; vlist.clear(); vlist << QVariant("checkbox"); vlist << QVariant(m_paths[i]->allowInterpolate()); plist["interpolate"] = vlist; vlist.clear(); vlist << QVariant("int"); vlist << QVariant(m_paths[i]->animateSpeed()); vlist << QVariant(10); vlist << QVariant(100); plist["animation speed"] = vlist; vlist.clear(); vlist << QVariant("checkbox"); vlist << QVariant(m_paths[i]->arrowForAll()); plist["arrows for all"] = vlist; vlist.clear(); vlist << QVariant("checkbox"); vlist << QVariant(m_sameForAll); plist["same for all"] = vlist; vlist.clear(); vlist << QVariant("checkbox"); vlist << QVariant(m_paths[i]->clip()); plist["clip"] = vlist; vlist.clear(); vlist << QVariant("checkbox"); vlist << QVariant(m_paths[i]->allowEditing()); plist["allow editing"] = vlist; vlist.clear(); vlist << QVariant("checkbox"); vlist << QVariant(m_paths[i]->blendMode()); plist["blend with volume"] = vlist; vlist.clear(); plist["command"] = vlist; vlist.clear(); QFile helpFile(":/pathgroups.help"); if (helpFile.open(QFile::ReadOnly)) { QTextStream in(&helpFile); QString line = in.readLine(); while (!line.isNull()) { if (line == "#begin") { QString keyword = in.readLine(); QString helptext; line = in.readLine(); while (!line.isNull()) { helptext += line; helptext += "\n"; line = in.readLine(); if (line == "#end") break; } vlist << keyword << helptext; } line = in.readLine(); } } plist["commandhelp"] = vlist; vlist.clear(); QString mesg; float pmin, pmax; m_paths[i]->pathlenMinmax(pmin, pmax); mesg = QString("min/max path lengths : %1 %2\n").arg(pmin).arg(pmax); float mins,maxs; mins = m_paths[i]->minScale(); maxs = m_paths[i]->maxScale(); mesg += QString("min/max scale : %1 %2\n").arg(mins).arg(maxs); vlist << mesg; plist["message"] = vlist; QStringList keys; keys << "color"; keys << "opacity"; keys << "depthcue"; keys << "gap"; keys << "filter on length"; keys << "length bounds"; keys << "scale type"; keys << "gap"; keys << "smoothness"; keys << "sections"; keys << "sparseness"; keys << "screen separation"; keys << "gap"; keys << "cap style"; keys << "arrow direction"; keys << "arrows for all"; keys << "gap"; keys << "animate"; keys << "interpolate"; keys << "animation speed"; keys << "gap"; keys << "same for all"; keys << "clip"; keys << "blend with volume"; keys << "allow editing"; keys << "command"; keys << "commandhelp"; keys << "message"; propertyEditor.set("Path Group Parameters", plist, keys); QMap<QString, QPair<QVariant, bool> > vmap; if (propertyEditor.exec() == QDialog::Accepted) vmap = propertyEditor.get(); else return true; keys = vmap.keys(); for(int ik=0; ik<keys.count(); ik++) { QPair<QVariant, bool> pair = vmap.value(keys[ik]); if (pair.second) { if (keys[ik] == "color") { QGradientStops stops = propertyEditor.getGradientStops(keys[ik]); m_paths[i]->setStops(stops); } else if (keys[ik] == "opacity") m_paths[i]->setOpacity(pair.first.toDouble()); else if (keys[ik] == "scale type") m_paths[i]->setScaleType(pair.first.toBool()); else if (keys[ik] == "sections") m_paths[i]->setSections(pair.first.toInt()); else if (keys[ik] == "smoothness") m_paths[i]->setSegments(pair.first.toInt()); else if (keys[ik] == "sparseness") m_paths[i]->setSparseness(pair.first.toInt()); else if (keys[ik] == "screen separation") m_paths[i]->setSeparation(pair.first.toInt()); else if (keys[ik] == "depthcue") m_paths[i]->setDepthcue(pair.first.toBool()); else if (keys[ik] == "animate") m_paths[i]->setAnimate(pair.first.toBool()); else if (keys[ik] == "interpolate") m_paths[i]->setAllowInterpolate(pair.first.toBool()); else if (keys[ik] == "animation speed") m_paths[i]->setAnimateSpeed(pair.first.toInt()); else if (keys[ik] == "cap style") m_paths[i]->setCapType(pair.first.toInt()); else if (keys[ik] == "arrow direction") m_paths[i]->setArrowDirection(pair.first.toInt()); else if (keys[ik] == "arrows for all") m_paths[i]->setArrowForAll(pair.first.toBool()); else if (keys[ik] == "same for all") { m_sameForAll = pair.first.toBool(); m_paths[i]->setSameForAll(m_sameForAll); } else if (keys[ik] == "clip") m_paths[i]->setClip(pair.first.toBool()); else if (keys[ik] == "allow editing") m_paths[i]->setAllowEditing(pair.first.toBool()); else if (keys[ik] == "blend with volume") m_paths[i]->setBlendMode(pair.first.toBool()); else if (keys[ik] == "filter on length") m_paths[i]->setFilterPathLen(pair.first.toBool()); else if (keys[ik] == "length bounds") { QString vstr = pair.first.toString(); QStringList vl = vstr.split(" ", QString::SkipEmptyParts); if (vl.count() == 2) m_paths[i]->setUserPathlenMinmax(vl[0].toDouble(), vl[1].toDouble()); } } } QString cmd = propertyEditor.getCommandString(); if (!cmd.isEmpty()) processCommand(i, cmd); updateGL(); } } } return true; }
QBrush XMLParseBase::parseGradient(const QDomElement &element) { QLinearGradient gradient; QString gradientStart = element.attribute("start", ""); QString gradientEnd = element.attribute("end", ""); int gradientAlpha = element.attribute("alpha", "255").toInt(); QString direction = element.attribute("direction", "vertical"); float x1, y1, x2, 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 { x1 = 0.0; x2 = 1.0; y1 = 0.5; y2 = 0.5; } gradient.setCoordinateMode(QGradient::ObjectBoundingMode); gradient.setStart(x1, y1); gradient.setFinalStop(x2, y2); QGradientStops stops; if (!gradientStart.isEmpty()) { QColor startColor = QColor(gradientStart); startColor.setAlpha(gradientAlpha); QGradientStop stop(0.0, startColor); stops.append(stop); } if (!gradientEnd.isEmpty()) { QColor endColor = QColor(gradientEnd); endColor.setAlpha(gradientAlpha); QGradientStop stop(1.0, endColor); 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); } } gradient.setStops(stops); return QBrush(gradient); }