void ParupaintColorWheel::paintEvent(QPaintEvent * event)
{
// QSS won't do much stuff.
const qreal max_ratio = (qreal)(this->rect().width() > this->rect().height() ? this->rect().height() : this->rect().width())/2.0;
QPoint rp = QPoint(max_ratio - wheel_width/2, max_ratio - wheel_width/2);
QRect rr = QRect(this->rect().center() - rp,
this->rect().center() + rp);
QPainter paint(this);
QConicalGradient gradient;
gradient.setCenter(this->rect().center());
gradient.setAngle(-90);
for(qreal i = 0; i <= 1; i += 0.1){
gradient.setColorAt(i, QColor::fromHslF(1.0 - i, 1, 0.5));
}
QPen pen(QBrush(gradient), wheel_width);
paint.setPen(pen);
paint.drawArc(rr, 0, 360 * 16);
qreal ttf = ((qreal(this->value()) / qreal(this->maximum()))*(M_PI*2) + M_PI/2);
QPoint pp = this->rect().center() + QPoint(qCos(ttf) * (max_ratio), qSin(ttf) * (max_ratio));
QPen pen2(Qt::black);
pen2.setWidth(2);
paint.setPen(pen2);
paint.drawLine(this->rect().center(), pp);
// this->QDial::paintEvent(event);
}
void Color_Wheel::render_ring()
{
hue_ring = QPixmap(outer_radius()*2,outer_radius()*2);
hue_ring.fill(Qt::transparent);
QPainter painter(&hue_ring);
painter.setRenderHint(QPainter::Antialiasing);
painter.setCompositionMode(QPainter::CompositionMode_Source);
const int hue_stops = 24;
static QConicalGradient gradient_hue(0, 0, 0);
if ( gradient_hue.stops().size() < hue_stops )
{
for ( double a = 0; a < 1.0; a+=1.0/(hue_stops-1) )
{
gradient_hue.setColorAt(a,QColor::fromHsvF(a,1,1));
}
gradient_hue.setColorAt(1,QColor::fromHsvF(0,1,1));
}
painter.translate(outer_radius(),outer_radius());
painter.setPen(Qt::NoPen);
painter.setBrush(QBrush(gradient_hue));
painter.drawEllipse(QPointF(0,0),outer_radius(),outer_radius());
painter.setBrush(Qt::transparent);//palette().background());
painter.drawEllipse(QPointF(0,0),inner_radius(),inner_radius());
}
//! [3]
void Enemy::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
{
//if (painter->paintEngine()->type() == QPaintEngine::OpenGL2 || painter->paintEngine()->type() == QPaintEngine::OpenGL){
// //qDebug()<<"OpenGL reporting!";
//}
// QPainter: (uses OpenGL for rectangles, ellipses etc. if above if-clause is true..?)
// Body
//painter->setBrush(myColour);
static QLinearGradient hullGradient(0,-25,0,5);
hullGradient.setColorAt(0, Qt::white);
hullGradient.setColorAt(1, myColour);
painter->setBrush(QBrush(hullGradient));
// painter->drawEllipse(-10, -20, 20, 40);
static const QPointF hullPoints[3] = {
QPointF(-5.0, 10),
QPointF(0, -30),
QPointF(5, 10)
};
painter->drawPolygon(hullPoints, 3);
// "Scanner" eye
painter->setBrush(Qt::red);
painter->drawEllipse(-4, -20, 8, 8);
// Guns
painter->setBrush(Qt::gray);
painter->drawRect(-16,-12,4,8);
painter->drawRect(12,-12,4,8);
// Pupil of "Scanner"
qreal dx = ::sin(Creature::myAngle) * 10;
myEyeDirection = (qAbs(dx / 5) < 1) ? 0 : dx / 5;
painter->drawEllipse(QRectF(-2.0 + 2*myEyeDirection, -22, 4, 4));
// Wings
//painter->setBrush(myIsCaught ? Qt::red : Qt::darkYellow);
static QConicalGradient wingGradient(0,12,180);
wingGradient.setColorAt(0, Qt::white);
wingGradient.setColorAt(1, Creature::myIsCaught ? Qt::red : Qt::darkYellow); //Qt::gray);
painter->setBrush(QBrush(wingGradient));
//1st way of implementing the wings
static const QPointF wingPoints[4] = {
QPointF(0, 12),
QPointF(-25, -14),
QPointF(0, 4),
QPointF(25, -14)
};
painter->drawPolygon(wingPoints, 4);
}
KoStopGradient * KoStopGradient::fromQGradient(QGradient * gradient)
{
if (! gradient)
return 0;
KoStopGradient * newGradient = new KoStopGradient("");
newGradient->setType(gradient->type());
newGradient->setSpread(gradient->spread());
switch (gradient->type()) {
case QGradient::LinearGradient: {
QLinearGradient * g = static_cast<QLinearGradient*>(gradient);
newGradient->m_start = g->start();
newGradient->m_stop = g->finalStop();
newGradient->m_focalPoint = g->start();
break;
}
case QGradient::RadialGradient: {
QRadialGradient * g = static_cast<QRadialGradient*>(gradient);
newGradient->m_start = g->center();
newGradient->m_stop = g->center() + QPointF(g->radius(), 0);
newGradient->m_focalPoint = g->focalPoint();
break;
}
case QGradient::ConicalGradient: {
QConicalGradient * g = static_cast<QConicalGradient*>(gradient);
qreal radian = g->angle() * M_PI / 180.0;
newGradient->m_start = g->center();
newGradient->m_stop = QPointF(100.0 * cos(radian), 100.0 * sin(radian));
newGradient->m_focalPoint = g->center();
break;
}
default:
delete newGradient;
return 0;
}
Q_FOREACH (const QGradientStop & stop, gradient->stops()) {
KoColor color(newGradient->colorSpace());
color.fromQColor(stop.second);
newGradient->m_stops.append(KoGradientStop(stop.first, color));
}
return newGradient;
}
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::testQConicalGradientSetters()
{
QConicalGradient cg;
QCOMPARE(cg.angle(), qreal(0.0));
QCOMPARE(cg.center(), QPointF(0, 0));
cg.setAngle(100);
QCOMPARE(cg.angle(), qreal(100.0));
cg.setCenter(102, 103);
QCOMPARE(cg.center(), QPointF(102, 103));
cg.setCenter(QPointF(202, 203));
QCOMPARE(cg.center(), QPointF(202, 203));
}
void QRoundProgressBar::rebuildDataBrushIfNeeded() {
if (m_rebuildBrush) {
m_rebuildBrush = false;
QConicalGradient dataBrush;
dataBrush.setCenter(0.5, 0.5);
dataBrush.setCoordinateMode(QGradient::StretchToDeviceMode);
// invert colors
for (int i = 0; i < m_gradientData.count(); i++) {
dataBrush.setColorAt(1.0 - m_gradientData.at(i).first, m_gradientData.at(i).second);
}
// angle
dataBrush.setAngle(m_nullPosition);
QPalette p(palette());
p.setBrush(QPalette::Highlight, dataBrush);
setPalette(p);
}
}
QgsColorWheel::QgsColorWheel( QWidget *parent )
: QgsColorWidget( parent )
, mMargin( 4 )
, mWheelThickness( 18 )
, mClickedPart( QgsColorWheel::None )
, mWheelImage( nullptr )
, mTriangleImage( nullptr )
, mWidgetImage( nullptr )
, mWheelDirty( true )
, mTriangleDirty( true )
{
//create wheel hue brush - only do this once
QConicalGradient wheelGradient = QConicalGradient( 0, 0, 0 );
int wheelStops = 20;
QColor gradColor = QColor::fromHsvF( 1.0, 1.0, 1.0 );
for ( int pos = 0; pos <= wheelStops; ++pos )
{
double relativePos = ( double )pos / wheelStops;
gradColor.setHsvF( relativePos, 1, 1 );
wheelGradient.setColorAt( relativePos, gradColor );
}
mWheelBrush = QBrush( wheelGradient );
}
void Mask::mask_slot(){
int countSel = gsri->countSelected();
GObjectInterface *iObj, *endObj=gsri->selected(gsri->countSelected()-1);//создаём контейнер с выделенными рамкой объектами
qreal k_h, k_w, width_iObj, width_endObj = endObj->boundingRect().width(),
height_iObj, height_endObj = endObj->boundingRect().height();
QBrush endObjBrush = endObj->brush();
if(endObjBrush.style() == Qt::RadialGradientPattern
|| endObjBrush.style() == Qt::ConicalGradientPattern
|| endObjBrush.style() == Qt::LinearGradientPattern){
for (int i=0; i<countSel-1; i++){
iObj = gsri->selected(i);
QBrush inters = iObj->brush();
qreal iObjAlpha = inters.color().alphaF();
QGradient qg = *endObjBrush.gradient();
height_iObj = iObj->boundingRect().height();
width_iObj = iObj->boundingRect().width();
k_h = height_endObj/height_iObj;//считаем коэффициенты пропорциональности фигур для умножения-->
k_w = width_endObj/width_iObj;//-->на точки градиента(чтобы градиенты не зависели от размеров фигур).
int d_x = iObj->boundingRect().x() - endObj->boundingRect().x();//вычисляем расстояния между левыми краями фигур
int d_y = iObj->boundingRect().y() - endObj->boundingRect().y();
qreal k_shift_x = ( d_x / width_endObj) * k_w,//вычисляем коэффициенты сдвига градиента по ширине-->
k_shift_y = (d_y / height_endObj) * k_h;//--> и по высотке
QGradientStops grStops(qg.stops());//копируем точки/цвета задаваемого градиента.
QColor BrushColor = inters.gradient()->stops()[0].second;
for(int j=0; j<grStops.count(); j++){
grStops[j].second.setRgbF( BrushColor.redF(), BrushColor.greenF(), BrushColor.blueF(),
grStops[j].second.alphaF()*iObjAlpha);
}
if(qg.type() == QGradient::LinearGradient){
QLinearGradient qlg = *static_cast<const QLinearGradient *>(endObjBrush.gradient());
QLinearGradient qlgLinear(qlg.start().x() * k_w - k_shift_x, qlg.start().y() * k_h - k_shift_y,
qlg.finalStop().x() * k_w - k_shift_x, qlg.finalStop().y() * k_h - k_shift_y);
qlgLinear.setStops(grStops);
iObj->setBrush(qlgLinear);
}
if(qg.type() == QGradient::RadialGradient){
for(int j=0; j<grStops.count(); j++)
grStops[j].first *= k_w;
QRadialGradient qlg = *static_cast<const QRadialGradient *>(endObjBrush.gradient());
QRadialGradient qlgRadial(QPointF(qlg.center().x()*k_w - k_shift_x, qlg.center().y()*k_h - k_shift_y),
qlg.radius(), QPointF(qlg.focalPoint().x()*k_w - k_shift_x, qlg.focalPoint().y()*k_h - k_shift_y),
qlg.focalRadius());
qlgRadial.setStops(grStops);
iObj->setBrush(qlgRadial);
}
if(qg.type() == QGradient::ConicalGradient){
QConicalGradient qlg = *static_cast<const QConicalGradient *>(endObjBrush.gradient());
QConicalGradient qlgConical(QPointF(qlg.center().x()*k_w - k_shift_x, qlg.center().y()*k_h - k_shift_y),
qlg.angle());
qlgConical.setStops(grStops);
iObj->setBrush(qlgConical);
}
}
endObj->setVisible(false);
}
else{
QMessageBox m;
m.setText(tr("upper figure does not contain a gradient"));
m.exec();
}
gsri->reset();
}
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;
}
}
