void EditorMagnifierItem::updateMask()
{
QRectF current = getRect();
QSize box = QSize( current.width(), current.width() );
// reupdate our mask
if (m_imgMask.size() != box)
{
int radius = box.width() / 2;
int ring = radius - 10;
m_imgMask = QPixmap(box);
m_imgMask.fill(Qt::transparent);
QRadialGradient g;
g.setCenter(radius, radius);
g.setFocalPoint(radius, radius);
g.setRadius(radius);
g.setColorAt( 1.0, QColor(255, 255, 255, 0) );
g.setColorAt( 0.5, QColor(128, 128, 128, 255) );
QPainter mask(&m_imgMask);
mask.setRenderHint(QPainter::Antialiasing);
mask.setCompositionMode(QPainter::CompositionMode_Source);
mask.setBrush(g);
mask.setPen(Qt::NoPen);
mask.drawRect( m_imgMask.rect() );
mask.setBrush( QColor(Qt::transparent) );
mask.drawEllipse(g.center(), ring, ring);
mask.end();
}
}
int MailTreeDelegate::DrawMessageActionIcons (QPainter *painter,
const QStyleOptionViewItem& option, const QModelIndex& index, int height) const
{
if (Mode_ != MailListMode::Normal)
return 0;
if (option.state & QStyle::State_MouseOver)
return 0;
const auto& actionsVar = index.data (MailModel::MailRole::MessageActions);
if (actionsVar.isNull ())
return 0;
auto actionInfos = actionsVar.value<QList<MessageListActionInfo>> ();
if (actionInfos.isEmpty ())
return 0;
std::reverse (actionInfos.begin (), actionInfos.end ());
if (ActionsHintsBalls_)
height -= Padding * 2;
painter->save ();
painter->setRenderHint (QPainter::Antialiasing);
painter->setPen (Qt::NoPen);
auto rect = option.rect;
rect.setLeft (rect.right () - height - Padding);
rect.setSize ({ height, height });
rect.moveTop (rect.top () + Padding);
for (const auto& item : actionInfos)
{
if (item.Flags_ & MessageListActionFlag::AlwaysPresent)
continue;
if (ActionsHintsBalls_)
{
QRadialGradient gradient;
gradient.setCoordinateMode (QGradient::ObjectBoundingMode);
gradient.setFocalPoint ({ 0.3, 0.3 });
gradient.setCenter ({ 0.5, 0.5 });
gradient.setRadius (0.5);
gradient.setColorAt (0, item.ReprColor_.lighter (200));
gradient.setColorAt (1, item.ReprColor_.darker (120));
painter->setBrush (gradient);
painter->drawEllipse (rect);
}
else
item.Icon_.paint (painter, rect);
rect.moveLeft (rect.left () - height - Padding);
}
painter->restore ();
return option.rect.right () - rect.right ();
}
void PreviewWidget::drawShadow(QPainter &painter, QRectF rect)
{
// Shadow width
int width = qBound(4, int(qMax(rect.height(), rect.width())) / 100, 7);
painter.save();
painter.setClipRect(rect.adjusted(0, 0, width, width));
QColor lightColor = this->palette().color(QPalette::Background);
QColor darkColor = lightColor.darker(160);
QRectF shadowRect = rect.adjusted(0, 0, width, width);
QLinearGradient lg;
lg.setColorAt(0.0, darkColor);
lg.setColorAt(1.0, lightColor);
QRadialGradient rg;
rg.setColorAt(0, darkColor);
rg.setColorAt(1, lightColor);
rg.setRadius(width);
// Right
lg.setStart(QPointF(rect.right(), rect.center().y()));
lg.setFinalStop(QPointF(shadowRect.right(), rect.center().y()));
painter.fillRect(rect.right(), rect.top() + width, width, rect.height() - width, lg);
// Bottom
lg.setStart(rect.center().x(), rect.bottom());
lg.setFinalStop(rect.center().x(), rect.bottom() + width);
painter.fillRect(rect.left() + width, rect.bottom(), rect.width() - width, width, lg);
//TopRight
QPointF p;
p = rect.bottomRight();
rg.setCenter(p);
rg.setFocalPoint(p);
painter.fillRect(rect.right(), rect.bottom(), width, width, rg);
// BottomRight
p = rect.topRight();
p.ry() += width;
rg.setCenter(p);
rg.setFocalPoint(p);
painter.fillRect(rect.right(), rect.top(), width, width, rg);
//BottomLeft
p = rect.bottomLeft();
p.rx() += width;
rg.setCenter(p);
rg.setFocalPoint(p);
painter.fillRect(rect.left(), rect.bottom(), width, width, rg);
painter.restore();
}
void BrushEngine::paint(const QPointF& point, float pressure) {
QPainter painter(eraser > 50 ? canvasItem->getPixmap() : canvasBuffer->getPixmap());
painter.setRenderHint(QPainter::Antialiasing, true);
painter.setPen(Qt::NoPen);
if (eraser > 50) {
painter.setCompositionMode(QPainter::CompositionMode_DestinationOut);
}
color.setAlpha(qRound(255 * flow / 100.0));
QColor pressureColor = color;
pressureColor.setAlpha(qRound(color.alpha() * pressure));
QColor alphaColor = color;
alphaColor.setAlpha(0);
QRadialGradient radialGradient;
radialGradient.setRadius(size / 2.0);
radialGradient.setColorAt(0, pressureColor);
radialGradient.setColorAt(1, alphaColor);
radialGradient.setColorAt(hardness / 100.0, pressureColor);
painter.setBrush(QBrush(radialGradient));
if (startPoint.isNull()) {
startPoint = QPointF(point);
lastPoint = QPointF(point);
topleft = QPoint(0, 0);
bottomright = QPoint(canvasBuffer->getPixmap()->width(), canvasBuffer->getPixmap()->height());
paintDab(point, painter);
} else {
qreal length = qSqrt(qPow(lastPoint.x() - point.x(), 2) + qPow(lastPoint.y() - point.y(), 2));
qreal delta = size * spacing / 2.0 / 100.0;
if (length >= delta) {
int dabs = qRound(length / delta);
qreal angle = qAtan2(point.x() - lastPoint.x(), point.y() - lastPoint.y());
qreal deltaX = delta * qSin(angle);
qreal deltaY = delta * qCos(angle);
QPointF betweenPoint;
for (int i = 1; i <= dabs; i++) {
qreal x = lastPoint.x() + deltaX * i +
(10000 - qrand() % 20000) / 10000.0 * size * jitter / 100;
qreal y = lastPoint.y() + deltaY * i +
(10000 - qrand() % 20000) / 10000.0 * size * jitter / 100;
betweenPoint = QPointF(x, y);
paintDab(betweenPoint, painter);
}
lastPoint = betweenPoint;
}
}
}
void PainterWidget::updateBrush()
{
QRadialGradient g;
g.setCenter(brush_size/2, brush_size/2);
g.setFocalPoint(brush_size/2, brush_size/2);
g.setRadius(brush_size/2);
g.setColorAt(1.0, Qt::black);
g.setColorAt(0, QColor(100,100,100));
QImage mask(brush_size, brush_size,QImage::Format_RGB32);
mask.fill(qRgb(0,0,0));
QPainter painter2(&mask);
painter2.fillRect(mask.rect(), g);
painter2.end();
soft_brush = QImage(brush_size, brush_size,QImage::Format_RGB32);
soft_brush.fill(brush_color.rgb());
soft_brush.setAlphaChannel(mask);
}
static QGradient loadGradient(const QDomElement &elem)
{
if (elem.tagName() != QLatin1String("gradientData"))
return QLinearGradient();
const QGradient::Type type = stringToGradientType(elem.attribute(QLatin1String("type")));
const QGradient::Spread spread = stringToGradientSpread(elem.attribute(QLatin1String("spread")));
const QGradient::CoordinateMode mode = stringToGradientCoordinateMode(elem.attribute(QLatin1String("coordinateMode")));
QGradient gradient = QLinearGradient();
if (type == QGradient::LinearGradient) {
QLinearGradient g;
g.setStart(elem.attribute(QLatin1String("startX")).toDouble(), elem.attribute(QLatin1String("startY")).toDouble());
g.setFinalStop(elem.attribute(QLatin1String("endX")).toDouble(), elem.attribute(QLatin1String("endY")).toDouble());
gradient = g;
} else if (type == QGradient::RadialGradient) {
QRadialGradient g;
g.setCenter(elem.attribute(QLatin1String("centerX")).toDouble(), elem.attribute(QLatin1String("centerY")).toDouble());
g.setFocalPoint(elem.attribute(QLatin1String("focalX")).toDouble(), elem.attribute(QLatin1String("focalY")).toDouble());
g.setRadius(elem.attribute(QLatin1String("radius")).toDouble());
gradient = g;
} else if (type == QGradient::ConicalGradient) {
QConicalGradient g;
g.setCenter(elem.attribute(QLatin1String("centerX")).toDouble(), elem.attribute(QLatin1String("centerY")).toDouble());
g.setAngle(elem.attribute(QLatin1String("angle")).toDouble());
gradient = g;
}
QDomElement stopElem = elem.firstChildElement();
while (!stopElem.isNull()) {
QGradientStop stop = loadGradientStop(stopElem);
gradient.setColorAt(stop.first, stop.second);
stopElem = stopElem.nextSiblingElement();
}
gradient.setSpread(spread);
gradient.setCoordinateMode(mode);
return gradient;
}
void tst_QBrush::testQRadialGradientSetters()
{
QRadialGradient rg;
QCOMPARE(rg.radius(), qreal(1.0));
QCOMPARE(rg.center(), QPointF(0, 0));
QCOMPARE(rg.focalPoint(), QPointF(0, 0));
rg.setRadius(100);
QCOMPARE(rg.radius(), qreal(100.0));
rg.setCenter(101, 102);
QCOMPARE(rg.center(), QPointF(101, 102));
rg.setCenter(QPointF(201, 202));
QCOMPARE(rg.center(), QPointF(201, 202));
rg.setFocalPoint(103, 104);
QCOMPARE(rg.focalPoint(), QPointF(103, 104));
rg.setFocalPoint(QPointF(203, 204));
QCOMPARE(rg.focalPoint(), QPointF(203, 204));
}
SpaceObjectSun::SpaceObjectSun(int x, int y)
: SpaceObject(x, y, SO_TYPE_SUN)
{
mPixmap->fill(Qt::transparent);
QPainter p(mPixmap);
QRadialGradient rd;
rd.setCenter(40, 40);
rd.setRadius(40);
rd.setFocalPoint(40, 40);
rd.setColorAt(0, QColor(0xFF, 0xFF, 0xDD, 0xFF));
rd.setColorAt(0.45, QColor(0xFF, 0xFF, 0xDD, 0xFF));
rd.setColorAt(0.55, QColor(0xFF, 0xFF, 0x33, 0xFF));
rd.setColorAt(0.6, QColor("#FF9900"));
rd.setColorAt(1, QColor( 0, 0, 0, 0x00 ));
p.setPen(Qt::NoPen);
p.setBrush( rd );
p.drawEllipse(0, 0, 80, 80);
}
QBrush XMLParseBase::parseGradient(const QDomElement &element)
{
QBrush brush;
QString gradientStart = element.attribute("start", "");
QString gradientEnd = element.attribute("end", "");
int gradientAlpha = element.attribute("alpha", "255").toInt();
QString direction = element.attribute("direction", "vertical");
QGradientStops stops;
if (!gradientStart.isEmpty())
{
QColor startColor = QColor(gradientStart);
startColor.setAlpha(gradientAlpha);
QGradientStop stop(0.0, startColor);
stops.append(stop);
}
for (QDomNode child = element.firstChild(); !child.isNull();
child = child.nextSibling())
{
QDomElement childElem = child.toElement();
if (childElem.tagName() == "stop")
{
float position = childElem.attribute("position", "0").toFloat();
QString color = childElem.attribute("color", "");
int alpha = childElem.attribute("alpha", "-1").toInt();
if (alpha < 0)
alpha = gradientAlpha;
QColor stopColor = QColor(color);
stopColor.setAlpha(alpha);
QGradientStop stop((position / 100), stopColor);
stops.append(stop);
}
}
if (!gradientEnd.isEmpty())
{
QColor endColor = QColor(gradientEnd);
endColor.setAlpha(gradientAlpha);
QGradientStop stop(1.0, endColor);
stops.append(stop);
}
if (direction == "radial")
{
QRadialGradient gradient;
gradient.setCoordinateMode(QGradient::ObjectBoundingMode);
float x1 = 0.5, y1 = 0.5, radius = 0.5;
gradient.setCenter(x1,y1);
gradient.setFocalPoint(x1,y1);
gradient.setRadius(radius);
gradient.setStops(stops);
brush = QBrush(gradient);
}
else // Linear
{
QLinearGradient gradient;
gradient.setCoordinateMode(QGradient::ObjectBoundingMode);
float x1 = 0.0, y1 = 0.0, x2 = 0.0, y2 = 0.0;
if (direction == "vertical")
{
x1 = 0.5;
x2 = 0.5;
y1 = 0.0;
y2 = 1.0;
}
else if (direction == "diagonal")
{
x1 = 0.0;
x2 = 1.0;
y1 = 0.0;
y2 = 1.0;
}
else // Horizontal
{
x1 = 0.0;
x2 = 1.0;
y1 = 0.5;
y2 = 0.5;
}
gradient.setStart(x1, y1);
gradient.setFinalStop(x2, y2);
gradient.setStops(stops);
brush = QBrush(gradient);
}
return brush;
}
void transferGradientPosition(const QGradient * srcGradient, QGradient * dstGradient)
{
// first check if gradients have the same type
if (srcGradient->type() == dstGradient->type()) {
switch (srcGradient->type()) {
case QGradient::LinearGradient: {
const QLinearGradient * src = static_cast<const QLinearGradient*>(srcGradient);
QLinearGradient * dst = static_cast<QLinearGradient*>(dstGradient);
dst->setStart(src->start());
dst->setFinalStop(src->finalStop());
break;
}
case QGradient::RadialGradient: {
const QRadialGradient * src = static_cast<const QRadialGradient*>(srcGradient);
QRadialGradient * dst = static_cast<QRadialGradient*>(dstGradient);
dst->setCenter(src->center());
dst->setRadius(src->radius());
dst->setFocalPoint(src->focalPoint());
break;
}
case QGradient::ConicalGradient: {
const QConicalGradient * src = static_cast<const QConicalGradient*>(srcGradient);
QConicalGradient * dst = static_cast<QConicalGradient*>(dstGradient);
dst->setCenter(src->center());
dst->setAngle(src->angle());
break;
}
default:
return;
}
return;
}
// try to preserve gradient positions as best as possible
QPointF start, stop;
switch (srcGradient->type()) {
case QGradient::LinearGradient: {
const QLinearGradient * g = static_cast<const QLinearGradient*>(srcGradient);
start = g->start();
stop = g->finalStop();
break;
}
case QGradient::RadialGradient: {
const QRadialGradient * g = static_cast<const QRadialGradient*>(srcGradient);
start = g->center();
stop = QPointF(g->radius(), 0.0);
break;
}
case QGradient::ConicalGradient: {
const QConicalGradient * g = static_cast<const QConicalGradient*>(srcGradient);
start = g->center();
qreal radAngle = g->angle() * M_PI / 180.0;
stop = QPointF(50.0 * cos(radAngle), 50.*sin(radAngle));
break;
}
default:
start = QPointF(0.0, 0.0);
stop = QPointF(50.0, 50.0);
}
switch (dstGradient->type()) {
case QGradient::LinearGradient: {
QLinearGradient * g = static_cast<QLinearGradient*>(dstGradient);
g->setStart(start);
g->setFinalStop(stop);
break;
}
case QGradient::RadialGradient: {
QRadialGradient * g = static_cast<QRadialGradient*>(dstGradient);
QPointF diff = stop - start;
qreal radius = sqrt(diff.x() * diff.x() + diff.y() * diff.y());
g->setCenter(start);
g->setFocalPoint(start);
g->setRadius(radius);
break;
}
case QGradient::ConicalGradient: {
QConicalGradient * g = static_cast<QConicalGradient*>(dstGradient);
QPointF diff = stop - start;
qreal angle = atan2(diff.y(), diff.x());
if (angle < 0.0)
angle += 2 * M_PI;
g->setCenter(start);
g->setAngle(angle*180 / M_PI);
break;
}
default:
return;
}
}
void Ckeyb::drawPressed(QImage *_img)
{
if (keyPressedList.isEmpty()) {
return;
}
keyPressing.lock();
QMapIterator<int, quint64> i(keyPressedList);
keyPressing.unlock();
while (i.hasNext()) {
i.next();
QRect _rect = getKey(i.key()).Rect;
_rect.setCoords(_rect.x()*pPC->internalImageRatio,
_rect.y()*pPC->internalImageRatio,
(_rect.x()+_rect.width())*pPC->internalImageRatio,
(_rect.y()+_rect.height())*pPC->internalImageRatio);
int _m = qMin(_rect.width(), _rect.height())*.25;
_rect+= QMargins(_m,_m,_m,_m);
int dim = qMax(_rect.width(), _rect.height());
int magnifierSize = dim * 2;
int radius = magnifierSize / 2;
int ring = radius - 15;
QSize box = QSize(magnifierSize, magnifierSize);
QPixmap maskPixmap;
maskPixmap = QPixmap(box);
maskPixmap.fill(Qt::transparent);
QRadialGradient g;
g.setCenter(radius, radius);
g.setFocalPoint(radius, radius);
g.setRadius(radius);
g.setColorAt(1.0, QColor(64, 64, 64, 0));
g.setColorAt(0.5, QColor(0, 0, 0, 255));
QPainter mask(&maskPixmap);
mask.setRenderHint(QPainter::Antialiasing);
mask.setCompositionMode(QPainter::CompositionMode_Source);
mask.setBrush(g);
mask.setPen(Qt::NoPen);
mask.drawRect(maskPixmap.rect());
mask.setBrush(QColor(Qt::transparent));
mask.drawEllipse(g.center(), ring, ring);
mask.end();
QPoint center = _rect.center() - QPoint(0, radius);
center = center + QPoint(0, radius / 2);
QPoint corner = center - QPoint(radius, radius);
QPoint xy = center * 2 - QPoint(radius, radius);
// only set the dimension to the magnified portion
QPixmap zoomPixmap = QPixmap(box);
zoomPixmap.fill(Qt::lightGray);
QPainter pz(&zoomPixmap);
// pz.translate(-xy);
QRect target=QRect(QPoint(0,0),box);
pz.drawImage(target, *_img,_rect);
pz.end();
QPainterPath clipPath;
clipPath.addEllipse(center, ring, ring);
QPainter p(_img);
p.setRenderHint(QPainter::Antialiasing);
p.setClipPath(clipPath);
p.drawPixmap(corner, zoomPixmap);
p.setClipping(false);
p.drawPixmap(corner, maskPixmap);
p.setPen(Qt::gray);
p.drawPath(clipPath);
p.end();
}
}
QPixmap ThumbBarDock::generateFuzzyRect(const QSize& size, const QColor& color, int radius)
{
QPixmap pix(size);
pix.fill(Qt::transparent);
QPainter painter(&pix);
painter.setRenderHint(QPainter::Antialiasing, true);
// Draw corners ----------------------------------
QRadialGradient gradient;
gradient.setColorAt(1, Qt::transparent);
gradient.setColorAt(0, color);
gradient.setRadius(radius);
QPoint center;
// Top Left
center = QPoint(radius, radius);
gradient.setCenter(center);
gradient.setFocalPoint(center);
painter.fillRect(0, 0, radius, radius, gradient);
// Top right
center = QPoint(size.width() - radius, radius);
gradient.setCenter(center);
gradient.setFocalPoint(center);
painter.fillRect(center.x(), 0, radius, radius, gradient);
// Bottom left
center = QPoint(radius, size.height() - radius);
gradient.setCenter(center);
gradient.setFocalPoint(center);
painter.fillRect(0, center.y(), radius, radius, gradient);
// Bottom right
center = QPoint(size.width() - radius, size.height() - radius);
gradient.setCenter(center);
gradient.setFocalPoint(center);
painter.fillRect(center.x(), center.y(), radius, radius, gradient);
// Draw borders ----------------------------------
QLinearGradient linearGradient;
linearGradient.setColorAt(1, Qt::transparent);
linearGradient.setColorAt(0, color);
// Top
linearGradient.setStart(0, radius);
linearGradient.setFinalStop(0, 0);
painter.fillRect(radius, 0, size.width() - 2*radius, radius, linearGradient);
// Bottom
linearGradient.setStart(0, size.height() - radius);
linearGradient.setFinalStop(0, size.height());
painter.fillRect(radius, int(linearGradient.start().y()), size.width() - 2*radius, radius, linearGradient);
// Left
linearGradient.setStart(radius, 0);
linearGradient.setFinalStop(0, 0);
painter.fillRect(0, radius, radius, size.height() - 2*radius, linearGradient);
// Right
linearGradient.setStart(size.width() - radius, 0);
linearGradient.setFinalStop(size.width(), 0);
painter.fillRect(int(linearGradient.start().x()), radius, radius, size.height() - 2*radius, linearGradient);
return pix;
}
bool SvgParser::parseGradient(const KoXmlElement &e, const KoXmlElement &referencedBy)
{
// IMPROVEMENTS:
// - Store the parsed colorstops in some sort of a cache so they don't need to be parsed again.
// - A gradient inherits attributes it does not have from the referencing gradient.
// - Gradients with no color stops have no fill or stroke.
// - Gradients with one color stop have a solid color.
SvgGraphicsContext *gc = m_context.currentGC();
if (!gc)
return false;
SvgGradientHelper gradhelper;
if (e.hasAttribute("xlink:href")) {
QString href = e.attribute("xlink:href").mid(1);
if (! href.isEmpty()) {
// copy the referenced gradient if found
SvgGradientHelper *pGrad = findGradient(href);
if (pGrad)
gradhelper = *pGrad;
} else {
//gc->fillType = SvgGraphicsContext::None; // <--- TODO Fill OR Stroke are none
return false;
}
}
// Use the gradient that is referencing, or if there isn't one, the original gradient.
KoXmlElement b;
if (!referencedBy.isNull())
b = referencedBy;
else
b = e;
QString gradientId = b.attribute("id");
if (! gradientId.isEmpty()) {
// check if we have this gradient already parsed
// copy existing gradient if it exists
if (m_gradients.find(gradientId) != m_gradients.end())
gradhelper.copyGradient(m_gradients[ gradientId ].gradient());
}
if (b.attribute("gradientUnits") == "userSpaceOnUse")
gradhelper.setGradientUnits(SvgGradientHelper::UserSpaceOnUse);
// parse color prop
QColor c = gc->currentColor;
if (!b.attribute("color").isEmpty()) {
m_context.styleParser().parseColor(c, b.attribute("color"));
} else {
// try style attr
QString style = b.attribute("style").simplified();
const QStringList substyles = style.split(';', QString::SkipEmptyParts);
for (QStringList::ConstIterator it = substyles.begin(); it != substyles.end(); ++it) {
QStringList substyle = it->split(':');
QString command = substyle[0].trimmed();
QString params = substyle[1].trimmed();
if (command == "color")
m_context.styleParser().parseColor(c, params);
}
}
gc->currentColor = c;
if (b.tagName() == "linearGradient") {
QLinearGradient *g = new QLinearGradient();
if (gradhelper.gradientUnits() == SvgGradientHelper::ObjectBoundingBox) {
g->setCoordinateMode(QGradient::ObjectBoundingMode);
g->setStart(QPointF(SvgUtil::fromPercentage(b.attribute("x1", "0%")),
SvgUtil::fromPercentage(b.attribute("y1", "0%"))));
g->setFinalStop(QPointF(SvgUtil::fromPercentage(b.attribute("x2", "100%")),
SvgUtil::fromPercentage(b.attribute("y2", "0%"))));
} else {
g->setStart(QPointF(SvgUtil::fromUserSpace(b.attribute("x1").toDouble()),
SvgUtil::fromUserSpace(b.attribute("y1").toDouble())));
g->setFinalStop(QPointF(SvgUtil::fromUserSpace(b.attribute("x2").toDouble()),
SvgUtil::fromUserSpace(b.attribute("y2").toDouble())));
}
// preserve color stops
if (gradhelper.gradient())
g->setStops(gradhelper.gradient()->stops());
gradhelper.setGradient(g);
} else if (b.tagName() == "radialGradient") {
QRadialGradient *g = new QRadialGradient();
if (gradhelper.gradientUnits() == SvgGradientHelper::ObjectBoundingBox) {
g->setCoordinateMode(QGradient::ObjectBoundingMode);
g->setCenter(QPointF(SvgUtil::fromPercentage(b.attribute("cx", "50%")),
SvgUtil::fromPercentage(b.attribute("cy", "50%"))));
g->setRadius(SvgUtil::fromPercentage(b.attribute("r", "50%")));
g->setFocalPoint(QPointF(SvgUtil::fromPercentage(b.attribute("fx", "50%")),
SvgUtil::fromPercentage(b.attribute("fy", "50%"))));
} else {
g->setCenter(QPointF(SvgUtil::fromUserSpace(b.attribute("cx").toDouble()),
SvgUtil::fromUserSpace(b.attribute("cy").toDouble())));
g->setFocalPoint(QPointF(SvgUtil::fromUserSpace(b.attribute("fx").toDouble()),
SvgUtil::fromUserSpace(b.attribute("fy").toDouble())));
g->setRadius(SvgUtil::fromUserSpace(b.attribute("r").toDouble()));
}
// preserve color stops
if (gradhelper.gradient())
g->setStops(gradhelper.gradient()->stops());
gradhelper.setGradient(g);
} else {
return false;
}
// handle spread method
QString spreadMethod = b.attribute("spreadMethod");
if (!spreadMethod.isEmpty()) {
if (spreadMethod == "reflect")
gradhelper.gradient()->setSpread(QGradient::ReflectSpread);
else if (spreadMethod == "repeat")
gradhelper.gradient()->setSpread(QGradient::RepeatSpread);
else
gradhelper.gradient()->setSpread(QGradient::PadSpread);
} else
gradhelper.gradient()->setSpread(QGradient::PadSpread);
// Parse the color stops. The referencing gradient does not have colorstops,
// so use the stops from the gradient it references to (e in this case and not b)
m_context.styleParser().parseColorStops(gradhelper.gradient(), e);
gradhelper.setTransform(SvgUtil::parseTransform(b.attribute("gradientTransform")));
m_gradients.insert(gradientId, gradhelper);
return true;
}
/**
* 重绘
* 实现只出现垂直滚动条的重载的画图事件处理方法。
*
*/
void TaskBallMapWidget::paintEvent(QPaintEvent * event )
{
// qLogx()<< __FUNCTION__ <<this->mBallBit.size()<<this->mBallMap.size()<<this->mCurrentTaskId;
QBrush brush(QColor(0, 0, 0));
//依靠currtaskid 判断是否需要重绘
if (this->mCurrentTaskId < 0) {
return;
}
if (this->mBallBit.size() <= 0) {
qLogx()<<__FUNCTION__<<QString("No bit set,");
// leave the widget raw clear
return;
}
//计算图象应该具有的宽度，splitter是以线性变化，而图形则必须以非线性变化，需要对取到的窗口宽度进行圆整
int width = this->mp->size().width() - 20 ;
if (width % (this->mBallRadius*2) != 0 ) {
width = ( (width / (this->mBallRadius*2)) ) * ( this->mBallRadius * 2) ;
} else {
width = (width / (this->mBallRadius*2)) * ( this->mBallRadius * 2) ;
}
//窗口的高度。
int height = this->mBallMap.height() ;
if (width != this->mBallMap.width()) {
//qLogx()<< "change to width:" << width ;
//需要改变图象大小。宽度
this->mBallMap = QImage(width , this->mBallMap.height() , QImage::Format_ARGB32_Premultiplied);
//this->mBallMap = this->mBallMap.scaledToWidth( width ) ;
//this->resize(width,height);
this->setFixedWidth( width );
}
if (this->mBallBit.size() != (width/(this->mBallRadius*2)) * (height/(this->mBallRadius*2))) {
height = (this->mBallRadius*2) * (this->mBallBit.size())/((width/(this->mBallRadius*2)));
if (height % (this->mBallRadius*2) != 0 ) {
height = ( 1+ (height / (this->mBallRadius*2)) ) * ( this->mBallRadius * 2);
} else {
height = ( height / (this->mBallRadius*2) ) * ( this->mBallRadius * 2);
}
//qLogx()<< "change to height: " << height ;
//需要改变图象大小。高度。
//this->mBallMap = this->mBallMap.scaledToHeight( (this->mCurrentLength / (this->mBlockSize))/((width/(this->mBallRadius*2)) ) * ( this->mBallRadius*2 ));
this->mBallMap = QImage(width, height, QImage::Format_ARGB32_Premultiplied);
//this->mBallMap = this->mBallMap.scaledToHeight(height);
//this->resize(width,height);
this->setFixedHeight(height); //设置本窗口构件的大小，使得外层的滚动构件能适当的添加或者删除滚动条。
}
// ball ball 48 0 // 0 true 600 0
// qLogx()<<__FUNCTION__<<this->mBallBit.size()<<this->mBallMap.isNull()<<width<<height;
if (this->mBallMap.isNull()) {
/*
if not check, show this error:
QPainter::begin: Paint device returned engine == 0, type: 3
QPainter::setRenderHint: Painter must be active to set rendering hints
QPainter::setBrush: Painter not active
QPainter::drawRects: Painter not active
QPainter::setBrush: Painter not active
QPainter::setBrush: Painter not actiev
*/
// this->mBallMap = QImage(mp->width(), mp->height(), QImage::Format_ARGB32_Premultiplied);
return;
}
QPainter imgp(&this->mBallMap) ;
imgp.setRenderHint(QPainter::Antialiasing, true);
imgp.setBrush(brush) ;
imgp.drawRect(0, 0, this->mBallMap.width(), this->mBallMap.height());
//更改前景颜色。
brush.setColor(QColor(0,255,0));
imgp.setBrush(brush);
//////////
QRadialGradient radgrad ; //梯度法
imgp.setBrush(radgrad) ;
int row = 0 , col = 0 ; //当前行，列
int mrow , mcol ; //最大行，列
int srow , scol ; //当前球块所在行，列。
mcol = width / (this->mBallRadius*2) ;
mrow = this->mBallBit.size() % mcol == 0 ?
(this->mBallBit.size() / mcol) : (this->mBallBit.size() / mcol + 1);
int mtb = this->mBallBit.size(); //所有球的个数。
// qLogx()<<"rows:"<<mrow<<"cols:"<<mcol;
for (int row = 0; row < mrow; row++) {
int sballno;
for (int col=0; col < mcol ; col ++) {
int bx, by, bw, bh;
sballno = row * mcol + col; //本球块在整个文件块中的序号。
if (sballno >= this->mBallBit.size()) {
break;
}
if (this->mBallBit.testBit(sballno) == false) {
continue;
}
bx = col * this->mBallRadius * 2; //本求块的右上角X值。
by = row * this->mBallRadius * 2; //本求块的右上角Y值。
//qLogx()<<"x,y,w"<<bx<<by<<(this->mBallRadius*2);
radgrad.setCenter(bx+this->mBallRadius, by + this->mBallRadius); //梯度参数设置
radgrad.setRadius(this->mBallRadius * 2 );
radgrad.setFocalPoint(bx+this->mBallRadius/2,by+this->mBallRadius/2);
radgrad.setColorAt(0.0,QColor(255,255,255));
radgrad.setColorAt(0.5,QColor(0,255,0));
radgrad.setColorAt(1.0,QColor(0,0,0));
imgp.setBrush(radgrad);
imgp.drawEllipse(bx,by,this->mBallRadius*2 , this->mBallRadius*2);
}
}
//输出到屏幕。
QPainter scrp(this);
scrp.drawImage(0, 0, this->mBallMap);
}
void AbstractDiagram::paintMarker( QPainter* painter,
const MarkerAttributes& markerAttributes,
const QBrush& brush,
const QPen& pen,
const QPointF& pos,
const QSizeF& maSize )
{
const QPen oldPen( painter->pen() );
// Pen is used to paint 4Pixels - 1 Pixel - Ring and FastCross types.
// make sure to use the brush color - see above in those cases.
const bool isFourPixels = (markerAttributes.markerStyle() == MarkerAttributes::Marker4Pixels);
if( isFourPixels || (markerAttributes.markerStyle() == MarkerAttributes::Marker1Pixel) ){
// for high-performance point charts with tiny point markers:
painter->setPen( PrintingParameters::scalePen( QPen( brush.color().light() ) ) );
if( isFourPixels ){
const qreal x = pos.x();
const qreal y = pos.y();
painter->drawLine( QPointF(x-1.0,y-1.0),
QPointF(x+1.0,y-1.0) );
painter->drawLine( QPointF(x-1.0,y),
QPointF(x+1.0,y) );
painter->drawLine( QPointF(x-1.0,y+1.0),
QPointF(x+1.0,y+1.0) );
}
painter->drawPoint( pos );
}else{
const PainterSaver painterSaver( painter );
// we only a solid line surrounding the markers
QPen painterPen( pen );
painterPen.setStyle( Qt::SolidLine );
painter->setPen( PrintingParameters::scalePen( painterPen ) );
painter->setBrush( brush );
painter->setRenderHint ( QPainter::Antialiasing );
painter->translate( pos );
switch ( markerAttributes.markerStyle() ) {
case MarkerAttributes::MarkerCircle:
{
if ( markerAttributes.threeD() ) {
QRadialGradient grad;
grad.setCoordinateMode( QGradient::ObjectBoundingMode );
QColor drawColor = brush.color();
grad.setCenter( 0.5, 0.5 );
grad.setRadius( 1.0 );
grad.setFocalPoint( 0.35, 0.35 );
grad.setColorAt( 0.00, drawColor.lighter( 150 ) );
grad.setColorAt( 0.20, drawColor );
grad.setColorAt( 0.50, drawColor.darker( 150 ) );
grad.setColorAt( 0.75, drawColor.darker( 200 ) );
grad.setColorAt( 0.95, drawColor.darker( 250 ) );
grad.setColorAt( 1.00, drawColor.darker( 200 ) );
QBrush newBrush( grad );
newBrush.setMatrix( brush.matrix() );
painter->setBrush( newBrush );
}
painter->drawEllipse( QRectF( 0 - maSize.height()/2, 0 - maSize.width()/2,
maSize.height(), maSize.width()) );
}
break;
case MarkerAttributes::MarkerSquare:
{
QRectF rect( 0 - maSize.width()/2, 0 - maSize.height()/2,
maSize.width(), maSize.height() );
painter->drawRect( rect );
break;
}
case MarkerAttributes::MarkerDiamond:
{
QVector <QPointF > diamondPoints;
QPointF top, left, bottom, right;
top = QPointF( 0, 0 - maSize.height()/2 );
left = QPointF( 0 - maSize.width()/2, 0 );
bottom = QPointF( 0, maSize.height()/2 );
right = QPointF( maSize.width()/2, 0 );
diamondPoints << top << left << bottom << right;
painter->drawPolygon( diamondPoints );
break;
}
// both handled on top of the method:
case MarkerAttributes::Marker1Pixel:
case MarkerAttributes::Marker4Pixels:
break;
case MarkerAttributes::MarkerRing:
{
painter->setPen( PrintingParameters::scalePen( QPen( brush.color() ) ) );
painter->setBrush( Qt::NoBrush );
painter->drawEllipse( QRectF( 0 - maSize.height()/2, 0 - maSize.width()/2,
maSize.height(), maSize.width()) );
break;
}
case MarkerAttributes::MarkerCross:
{
// Note: Markers can have outline,
// so just drawing two rects is NOT the solution here!
const qreal w02 = maSize.width() * 0.2;
const qreal w05 = maSize.width() * 0.5;
const qreal h02 = maSize.height()* 0.2;
const qreal h05 = maSize.height()* 0.5;
QVector <QPointF > crossPoints;
QPointF p[12];
p[ 0] = QPointF( -w02, -h05 );
p[ 1] = QPointF( w02, -h05 );
p[ 2] = QPointF( w02, -h02 );
p[ 3] = QPointF( w05, -h02 );
p[ 4] = QPointF( w05, h02 );
p[ 5] = QPointF( w02, h02 );
p[ 6] = QPointF( w02, h05 );
p[ 7] = QPointF( -w02, h05 );
p[ 8] = QPointF( -w02, h02 );
p[ 9] = QPointF( -w05, h02 );
p[10] = QPointF( -w05, -h02 );
p[11] = QPointF( -w02, -h02 );
for( int i=0; i<12; ++i )
crossPoints << p[i];
crossPoints << p[0];
painter->drawPolygon( crossPoints );
break;
}
case MarkerAttributes::MarkerFastCross:
{
QPointF left, right, top, bottom;
left = QPointF( -maSize.width()/2, 0 );
right = QPointF( maSize.width()/2, 0 );
top = QPointF( 0, -maSize.height()/2 );
bottom= QPointF( 0, maSize.height()/2 );
painter->setPen( PrintingParameters::scalePen( QPen( brush.color() ) ) );
painter->drawLine( left, right );
painter->drawLine( top, bottom );
break;
}
case MarkerAttributes::NoMarker:
break;
default:
Q_ASSERT_X ( false, "paintMarkers()",
"Type item does not match a defined Marker Type." );
}
}
painter->setPen( oldPen );
}
void LightMaps::paintEvent(QPaintEvent *event)
{
QPainter p;
p.begin(this);
m_normalMap->render(&p, event->rect());
p.setPen(Qt::black);
p.drawText(rect(), Qt::AlignBottom | Qt::TextWordWrap,
"Map data CCBYSA 2009 OpenStreetMap.org contributors");
p.end();
if (zoomed) {
int dim = qMin(width(), height());
int magnifierSize = qMin(MAX_MAGNIFIER, dim * 2 / 3);
int radius = magnifierSize / 2;
int ring = radius - 15;
QSize box = QSize(magnifierSize, magnifierSize);
// reupdate our mask
if (maskPixmap.size() != box) {
maskPixmap = QPixmap(box);
maskPixmap.fill(Qt::transparent);
QRadialGradient g;
g.setCenter(radius, radius);
g.setFocalPoint(radius, radius);
g.setRadius(radius);
g.setColorAt(1.0, QColor(255, 255, 255, 0));
g.setColorAt(0.5, QColor(128, 128, 128, 255));
QPainter mask(&maskPixmap);
mask.setRenderHint(QPainter::Antialiasing);
mask.setCompositionMode(QPainter::CompositionMode_Source);
mask.setBrush(g);
mask.setPen(Qt::NoPen);
mask.drawRect(maskPixmap.rect());
mask.setBrush(QColor(Qt::transparent));
mask.drawEllipse(g.center(), ring, ring);
mask.end();
}
QPoint center = dragPos - QPoint(0, radius);
center = center + QPoint(0, radius / 2);
QPoint corner = center - QPoint(radius, radius);
QPoint xy = center * 2 - QPoint(radius, radius);
// only set the dimension to the magnified portion
if (zoomPixmap.size() != box) {
zoomPixmap = QPixmap(box);
zoomPixmap.fill(Qt::lightGray);
}
if (true) {
QPainter p(&zoomPixmap);
p.translate(-xy);
m_largeMap->render(&p, QRect(xy, box));
p.end();
}
QPainterPath clipPath;
clipPath.addEllipse(center, ring, ring);
QPainter p(this);
p.setRenderHint(QPainter::Antialiasing);
p.setClipPath(clipPath);
p.drawPixmap(corner, zoomPixmap);
p.setClipping(false);
p.drawPixmap(corner, maskPixmap);
p.setPen(Qt::gray);
p.drawPath(clipPath);
}
if (invert) {
QPainter p(this);
p.setCompositionMode(QPainter::CompositionMode_Difference);
p.fillRect(event->rect(), Qt::white);
p.end();
}
}
QPixmap PostEffect::generateFuzzyRect(const QSize& size, const QColor& color, int radius)
{
QPixmap pix(size);
const QColor transparent(0, 0, 0, 0);
pix.fill(transparent);
QPainter painter(&pix);
painter.setRenderHint(QPainter::Antialiasing, true);
// Fill middle
painter.fillRect(pix.rect().adjusted(radius, radius, -radius, -radius), color);
// Corners
QRadialGradient gradient;
gradient.setColorAt(0, color);
gradient.setColorAt(1, transparent);
gradient.setRadius(radius);
QPoint center;
// Top Left
center = QPoint(radius, radius);
gradient.setCenter(center);
gradient.setFocalPoint(center);
painter.fillRect(0, 0, radius, radius, gradient);
// Top right
center = QPoint(size.width() - radius, radius);
gradient.setCenter(center);
gradient.setFocalPoint(center);
painter.fillRect(center.x(), 0, radius, radius, gradient);
// Bottom left
center = QPoint(radius, size.height() - radius);
gradient.setCenter(center);
gradient.setFocalPoint(center);
painter.fillRect(0, center.y(), radius, radius, gradient);
// Bottom right
center = QPoint(size.width() - radius, size.height() - radius);
gradient.setCenter(center);
gradient.setFocalPoint(center);
painter.fillRect(center.x(), center.y(), radius, radius, gradient);
// Borders
QLinearGradient linearGradient;
linearGradient.setColorAt(0, color);
linearGradient.setColorAt(1, transparent);
// Top
linearGradient.setStart(0, radius);
linearGradient.setFinalStop(0, 0);
painter.fillRect(radius, 0, size.width() - 2 * radius, radius, linearGradient);
// Bottom
linearGradient.setStart(0, size.height() - radius);
linearGradient.setFinalStop( 0, size.height() );
painter.fillRect(radius, int( linearGradient.start().y() ), size.width() - 2 * radius, radius, linearGradient);
// Left
linearGradient.setStart(radius, 0);
linearGradient.setFinalStop(0, 0);
painter.fillRect(0, radius, radius, size.height() - 2 * radius, linearGradient);
// Right
linearGradient.setStart(size.width() - radius, 0);
linearGradient.setFinalStop(size.width(), 0);
painter.fillRect(int( linearGradient.start().x() ), radius, radius, size.height() - 2 * radius, linearGradient);
return pix;
}
