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);
}
