Qt
Internal/Contributor docs for the Qt SDK. Note: These are NOT official API docs; those are found at https://doc.qt.io/
Loading...
Searching...
No Matches
qtgradientwidget.cpp
Go to the documentation of this file.
1// Copyright (C) 2016 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3// Qt-Security score:significant reason:default
4
5#include "qtgradientwidget_p.h"
6#include <QtCore/qmap.h>
7#include <QtGui/qimage.h>
8#include <QtGui/qpainter.h>
9#include <QtWidgets/qscrollbar.h>
10#include <QtGui/qevent.h>
11#include <QtGui/qregion.h>
12
13#ifndef _USE_MATH_DEFINES
14#define _USE_MATH_DEFINES
15#endif
16
17#include "qmath.h"
18
19QT_BEGIN_NAMESPACE
20
21class QtGradientWidgetPrivate
22{
23 QtGradientWidget *q_ptr;
24 Q_DECLARE_PUBLIC(QtGradientWidget)
25public:
26 QPointF fromViewport(QPointF point) const;
27 QPointF toViewport(QPointF point) const;
28// void setupDrag(QtGradientStop *stop, int x);
29
30 QPointF checkRange(QPointF point) const;
31 QRectF pointRect(QPointF point, double size) const;
32
33 double correctAngle(double angle) const;
34 void setAngleConical(double angle);
35
36 void paintPoint(QPainter *painter, QPointF point, double size) const;
37
38 double m_handleSize;
39 bool m_backgroundCheckered;
40
41 QGradientStops m_gradientStops;
42 QGradient::Type m_gradientType;
43 QGradient::Spread m_gradientSpread;
44 QPointF m_startLinear;
45 QPointF m_endLinear;
46 QPointF m_centralRadial;
47 QPointF m_focalRadial;
48 qreal m_radiusRadial;
49 QPointF m_centralConical;
50 qreal m_angleConical;
51
62
63 Handle m_dragHandle;
64 QPointF m_dragOffset;
65 //double m_radiusOffset;
66 double m_radiusFactor;
67 double m_dragRadius;
68 double m_angleOffset;
69 double m_dragAngle;
70};
71
72double QtGradientWidgetPrivate::correctAngle(double angle) const
73{
74 double a = angle;
75 while (a >= 360)
76 a -= 360;
77 while (a < 0)
78 a += 360;
79 return a;
80}
81
82void QtGradientWidgetPrivate::setAngleConical(double angle)
83{
84 double a = correctAngle(angle);
85 if (m_angleConical == a)
86 return;
87 m_angleConical = a;
88 emit q_ptr->angleConicalChanged(m_angleConical);
89}
90
91QRectF QtGradientWidgetPrivate::pointRect(QPointF point, double size) const
92{
93 return QRectF(point.x() - size / 2, point.y() - size / 2, size, size);
94}
95
96QPointF QtGradientWidgetPrivate::checkRange(QPointF point) const
97{
98 QPointF p = point;
99 if (p.x() > 1)
100 p.setX(1);
101 else if (p.x() < 0)
102 p.setX(0);
103 if (p.y() > 1)
104 p.setY(1);
105 else if (p.y() < 0)
106 p.setY(0);
107 return p;
108}
109
110QPointF QtGradientWidgetPrivate::fromViewport(QPointF point) const
111{
112 QSize size = q_ptr->size();
113 return QPointF(point.x() / size.width(), point.y() / size.height());
114}
115
116QPointF QtGradientWidgetPrivate::toViewport(QPointF point) const
117{
118 QSize size = q_ptr->size();
119 return QPointF(point.x() * size.width(), point.y() * size.height());
120}
121
122void QtGradientWidgetPrivate::paintPoint(QPainter *painter, QPointF point,
123 double size) const
124{
125 QPointF pf = toViewport(point);
126 QRectF rf = pointRect(pf, size);
127
128 QPen pen;
129 pen.setWidthF(1);
130 QColor alphaZero = Qt::white;
131 alphaZero.setAlpha(0);
132
133 painter->save();
134 painter->drawEllipse(rf);
135
136 /*
137 painter->save();
138
139 QLinearGradient lgV(0, rf.top(), 0, rf.bottom());
140 lgV.setColorAt(0, alphaZero);
141 lgV.setColorAt(0.25, Qt::white);
142 lgV.setColorAt(0.25, Qt::white);
143 lgV.setColorAt(1, alphaZero);
144 pen.setBrush(lgV);
145 painter->setPen(pen);
146
147 painter->drawLine(QPointF(pf.x(), rf.top()), QPointF(pf.x(), rf.bottom()));
148
149 QLinearGradient lgH(rf.left(), 0, rf.right(), 0);
150 lgH.setColorAt(0, alphaZero);
151 lgH.setColorAt(0.5, Qt::white);
152 lgH.setColorAt(1, alphaZero);
153 pen.setBrush(lgH);
154 painter->setPen(pen);
155
156 painter->drawLine(QPointF(rf.left(), pf.y()), QPointF(rf.right(), pf.y()));
157
158 painter->restore();
159 */
160
161 painter->restore();
162}
163
164/*
165void QtGradientWidgetPrivate::setupDrag(QtGradientStop *stop, int x)
166{
167 m_model->setCurrentStop(stop);
168
169 int viewportX = qRound(toViewport(stop->position()));
170 m_dragOffset = x - viewportX;
171
172 const auto stops = m_stops;
173 m_stops.clear();
174 for (QtGradientStop *s : stops) {
175 if (m_model->isSelected(s) || s == stop) {
176 m_dragStops[s] = s->position() - stop->position();
177 m_stops.append(s);
178 } else {
179 m_dragOriginal[s->position()] = s->color();
180 }
181 }
182 for (QtGradientStop *s : stops) {
183 if (!m_model->isSelected(s))
184 m_stops.append(s);
185 }
186 m_stops.removeAll(stop);
187 m_stops.prepend(stop);
188}
189*/
190////////////////////////////
191
192QtGradientWidget::QtGradientWidget(QWidget *parent)
193 : QWidget(parent), d_ptr(new QtGradientWidgetPrivate)
194{
195 d_ptr->q_ptr = this;
196 d_ptr->m_backgroundCheckered = true;
197 d_ptr->m_handleSize = 20.0;
198 d_ptr->m_gradientType = QGradient::LinearGradient;
199 d_ptr->m_startLinear = QPointF(0, 0);
200 d_ptr->m_endLinear = QPointF(1, 1);
201 d_ptr->m_centralRadial = QPointF(0.5, 0.5);
202 d_ptr->m_focalRadial = QPointF(0.5, 0.5);
203 d_ptr->m_radiusRadial = 0.5;
204 d_ptr->m_centralConical = QPointF(0.5, 0.5);
205 d_ptr->m_angleConical = 0;
206 d_ptr->m_dragHandle = QtGradientWidgetPrivate::NoHandle;
207
208 setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred));
209}
210
211QtGradientWidget::~QtGradientWidget()
212{
213}
214
215QSize QtGradientWidget::sizeHint() const
216{
217 return QSize(176, 176);
218}
219
220QSize QtGradientWidget::minimumSizeHint() const
221{
222 return QSize(128, 128);
223}
224
225int QtGradientWidget::heightForWidth(int w) const
226{
227 return w;
228}
229
230void QtGradientWidget::setBackgroundCheckered(bool checkered)
231{
232 if (d_ptr->m_backgroundCheckered == checkered)
233 return;
234 d_ptr->m_backgroundCheckered = checkered;
235 update();
236}
237
238bool QtGradientWidget::isBackgroundCheckered() const
239{
240 return d_ptr->m_backgroundCheckered;
241}
242
243void QtGradientWidget::mousePressEvent(QMouseEvent *e)
244{
245 if (e->button() != Qt::LeftButton)
246 return;
247
248 QPoint p = e->pos();
249 if (d_ptr->m_gradientType == QGradient::LinearGradient) {
250 QPointF startPoint = d_ptr->toViewport(d_ptr->m_startLinear);
251 double x = p.x() - startPoint.x();
252 double y = p.y() - startPoint.y();
253
254 if ((d_ptr->m_handleSize * d_ptr->m_handleSize / 4) > (x * x + y * y)) {
255 d_ptr->m_dragHandle = QtGradientWidgetPrivate::StartLinearHandle;
256 d_ptr->m_dragOffset = QPointF(x, y);
257 update();
258 return;
259 }
260
261 QPointF endPoint = d_ptr->toViewport(d_ptr->m_endLinear);
262 x = p.x() - endPoint.x();
263 y = p.y() - endPoint.y();
264
265 if ((d_ptr->m_handleSize * d_ptr->m_handleSize / 4) > (x * x + y * y)) {
266 d_ptr->m_dragHandle = QtGradientWidgetPrivate::EndLinearHandle;
267 d_ptr->m_dragOffset = QPointF(x, y);
268 update();
269 return;
270 }
271 } else if (d_ptr->m_gradientType == QGradient::RadialGradient) {
272 QPointF focalPoint = d_ptr->toViewport(d_ptr->m_focalRadial);
273 double x = p.x() - focalPoint.x();
274 double y = p.y() - focalPoint.y();
275
276 if ((d_ptr->m_handleSize * d_ptr->m_handleSize / 9) > (x * x + y * y)) {
277 d_ptr->m_dragHandle = QtGradientWidgetPrivate::FocalRadialHandle;
278 d_ptr->m_dragOffset = QPointF(x, y);
279 update();
280 return;
281 }
282
283 QPointF centralPoint = d_ptr->toViewport(d_ptr->m_centralRadial);
284 x = p.x() - centralPoint.x();
285 y = p.y() - centralPoint.y();
286
287 if ((d_ptr->m_handleSize * d_ptr->m_handleSize / 4) > (x * x + y * y)) {
288 d_ptr->m_dragHandle = QtGradientWidgetPrivate::CentralRadialHandle;
289 d_ptr->m_dragOffset = QPointF(x, y);
290 update();
291 return;
292 }
293
294 QPointF central = d_ptr->toViewport(d_ptr->m_centralRadial);
295 QRectF r = d_ptr->pointRect(central, 2 * d_ptr->m_handleSize / 3);
296 QRectF r1(0, r.y(), size().width(), r.height());
297 QRectF r2(r.x(), 0, r.width(), r.y());
298 QRectF r3(r.x(), r.y() + r.height(), r.width(), size().height() - r.y() - r.height());
299 QPointF pF(p.x(), p.y());
300 if (r1.contains(pF) || r2.contains(pF) || r3.contains(pF)) {
301 x = pF.x() / size().width() - d_ptr->m_centralRadial.x();
302 y = pF.y() / size().height() - d_ptr->m_centralRadial.y();
303 const double clickRadius = hypot(x, y);
304 //d_ptr->m_radiusOffset = d_ptr->m_radiusRadial - clickRadius;
305 d_ptr->m_radiusFactor = d_ptr->m_radiusRadial / clickRadius;
306 if (d_ptr->m_radiusFactor == 0)
307 d_ptr->m_radiusFactor = 1;
308 d_ptr->m_dragRadius = d_ptr->m_radiusRadial;
309 d_ptr->m_dragHandle = QtGradientWidgetPrivate::RadiusRadialHandle;
310 mouseMoveEvent(e);
311 update();
312 return;
313 }
314 } else if (d_ptr->m_gradientType == QGradient::ConicalGradient) {
315 QPointF centralPoint = d_ptr->toViewport(d_ptr->m_centralConical);
316 double x = p.x() - centralPoint.x();
317 double y = p.y() - centralPoint.y();
318
319 if ((d_ptr->m_handleSize * d_ptr->m_handleSize / 4) > (x * x + y * y)) {
320 d_ptr->m_dragHandle = QtGradientWidgetPrivate::CentralConicalHandle;
321 d_ptr->m_dragOffset = QPointF(x, y);
322 update();
323 return;
324 }
325 double radius = size().width();
326 if (size().height() < radius)
327 radius = size().height();
328 radius /= 2;
329 double corr = d_ptr->m_handleSize / 3;
330 radius -= corr;
331 QPointF vp = d_ptr->toViewport(d_ptr->m_centralConical);
332 x = p.x() - vp.x();
333 y = p.y() - vp.y();
334 if (((radius - corr) * (radius - corr) < (x * x + y * y)) &&
335 ((radius + corr) * (radius + corr) > (x * x + y * y))) {
336 QPointF central = d_ptr->toViewport(d_ptr->m_centralConical);
337 QPointF current(e->pos().x(), e->pos().y());
338 x = current.x() - central.x();
339 y = current.y() - central.y();
340 x /= size().width() / 2;
341 y /= size().height() / 2;
342 const double angle = qRadiansToDegrees(atan2(-y, x));
343
344 d_ptr->m_angleOffset = d_ptr->m_angleConical - angle;
345 d_ptr->m_dragAngle = d_ptr->m_angleConical;
346 d_ptr->m_dragHandle = QtGradientWidgetPrivate::AngleConicalHandle;
347 update();
348 return;
349 }
350 }
351}
352
353void QtGradientWidget::mouseReleaseEvent(QMouseEvent *e)
354{
355 Q_UNUSED(e);
356 d_ptr->m_dragHandle = QtGradientWidgetPrivate::NoHandle;
357 update();
358}
359
360void QtGradientWidget::mouseMoveEvent(QMouseEvent *e)
361{
362 if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::NoHandle)
363 return;
364
365 const QPointF newPos = e->position() - d_ptr->m_dragOffset;
366 QPointF newPoint = d_ptr->fromViewport(newPos);
367 if (newPoint.x() < 0)
368 newPoint.setX(0);
369 else if (newPoint.x() > 1)
370 newPoint.setX(1);
371 if (newPoint.y() < 0)
372 newPoint.setY(0);
373 else if (newPoint.y() > 1)
374 newPoint.setY(1);
375
376 if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::StartLinearHandle) {
377 d_ptr->m_startLinear = newPoint;
378 emit startLinearChanged(newPoint);
379 } else if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::EndLinearHandle) {
380 d_ptr->m_endLinear = newPoint;
381 emit endLinearChanged(newPoint);
382 } else if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::CentralRadialHandle) {
383 d_ptr->m_centralRadial = newPoint;
384 emit centralRadialChanged(newPoint);
385 } else if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::FocalRadialHandle) {
386 d_ptr->m_focalRadial = newPoint;
387 emit focalRadialChanged(newPoint);
388 } else if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::RadiusRadialHandle) {
389 QPointF centralPoint = d_ptr->toViewport(d_ptr->m_centralRadial);
390 QPointF pF(e->pos().x(), e->pos().y());
391 double x = pF.x() - centralPoint.x();
392 double y = pF.y() - centralPoint.y();
393
394 if ((d_ptr->m_handleSize * d_ptr->m_handleSize / 4) > (x * x + y * y)) {
395 if (d_ptr->m_radiusRadial != d_ptr->m_dragRadius) {
396 d_ptr->m_radiusRadial = d_ptr->m_dragRadius;
397 emit radiusRadialChanged(d_ptr->m_radiusRadial);
398 }
399 } else {
400 x = pF.x() / size().width() - d_ptr->m_centralRadial.x();
401 y = pF.y() / size().height() - d_ptr->m_centralRadial.y();
402 const double moveRadius = hypot(x, y);
403 //double newRadius = moveRadius + d_ptr->m_radiusOffset;
404 double newRadius = moveRadius * d_ptr->m_radiusFactor;
405 if (newRadius > 2)
406 newRadius = 2;
407 d_ptr->m_radiusRadial = newRadius;
408 emit radiusRadialChanged(d_ptr->m_radiusRadial);
409 }
410 } else if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::CentralConicalHandle) {
411 d_ptr->m_centralConical = newPoint;
412 emit centralConicalChanged(newPoint);
413 } else if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::AngleConicalHandle) {
414 QPointF centralPoint = d_ptr->toViewport(d_ptr->m_centralConical);
415 QPointF pF(e->pos().x(), e->pos().y());
416 double x = pF.x() - centralPoint.x();
417 double y = pF.y() - centralPoint.y();
418
419 if ((d_ptr->m_handleSize * d_ptr->m_handleSize / 4) > (x * x + y * y)) {
420 if (d_ptr->m_angleConical != d_ptr->m_dragAngle) {
421 d_ptr->m_angleConical = d_ptr->m_dragAngle;
422 emit angleConicalChanged(d_ptr->m_angleConical);
423 }
424 } else {
425 QPointF central = d_ptr->toViewport(d_ptr->m_centralConical);
426 QPointF current = pF;
427 x = current.x() - central.x();
428 y = current.y() - central.y();
429 x /= size().width() / 2;
430 y /= size().height() / 2;
431
432 const double angle = qRadiansToDegrees(atan2(-y, x)) + d_ptr->m_angleOffset;
433 d_ptr->setAngleConical(angle);
434 }
435 }
436 update();
437}
438
439void QtGradientWidget::mouseDoubleClickEvent(QMouseEvent *e)
440{
441 mousePressEvent(e);
442}
443
444void QtGradientWidget::paintEvent(QPaintEvent *e)
445{
446 Q_UNUSED(e);
447
448 QPainter p(this);
449
450 if (d_ptr->m_backgroundCheckered) {
451 int pixSize = 40;
452 QPixmap pm(2 * pixSize, 2 * pixSize);
453
454 QPainter pmp(&pm);
455 pmp.fillRect(0, 0, pixSize, pixSize, Qt::white);
456 pmp.fillRect(pixSize, pixSize, pixSize, pixSize, Qt::white);
457 pmp.fillRect(0, pixSize, pixSize, pixSize, Qt::black);
458 pmp.fillRect(pixSize, 0, pixSize, pixSize, Qt::black);
459
460 p.setBrushOrigin((size().width() % pixSize + pixSize) / 2, (size().height() % pixSize + pixSize) / 2);
461 p.fillRect(rect(), pm);
462 p.setBrushOrigin(0, 0);
463 }
464
465 QGradient *gradient = nullptr;
466 switch (d_ptr->m_gradientType) {
467 case QGradient::LinearGradient:
468 gradient = new QLinearGradient(d_ptr->m_startLinear, d_ptr->m_endLinear);
469 break;
470 case QGradient::RadialGradient:
471 gradient = new QRadialGradient(d_ptr->m_centralRadial, d_ptr->m_radiusRadial, d_ptr->m_focalRadial);
472 break;
473 case QGradient::ConicalGradient:
474 gradient = new QConicalGradient(d_ptr->m_centralConical, d_ptr->m_angleConical);
475 break;
476 default:
477 break;
478 }
479 if (!gradient)
480 return;
481
482 gradient->setStops(d_ptr->m_gradientStops);
483 gradient->setSpread(d_ptr->m_gradientSpread);
484
485 p.save();
486 p.scale(size().width(), size().height());
487 p.fillRect(QRect(0, 0, 1, 1), *gradient);
488 p.restore();
489
490 p.setRenderHint(QPainter::Antialiasing);
491
492 QColor c = QColor::fromRgbF(0.5, 0.5, 0.5, 0.5);
493 QBrush br(c);
494 p.setBrush(br);
495 QPen pen(Qt::white);
496 pen.setWidthF(1);
497 p.setPen(pen);
498 QPen dragPen = pen;
499 dragPen.setWidthF(2);
500 if (d_ptr->m_gradientType == QGradient::LinearGradient) {
501 p.save();
502 if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::StartLinearHandle)
503 p.setPen(dragPen);
504 d_ptr->paintPoint(&p, d_ptr->m_startLinear, d_ptr->m_handleSize);
505 p.restore();
506
507 p.save();
508 if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::EndLinearHandle)
509 p.setPen(dragPen);
510 d_ptr->paintPoint(&p, d_ptr->m_endLinear, d_ptr->m_handleSize);
511 p.restore();
512 } else if (d_ptr->m_gradientType == QGradient::RadialGradient) {
513 QPointF central = d_ptr->toViewport(d_ptr->m_centralRadial);
514
515 p.save();
516 QRectF r = d_ptr->pointRect(central, 2 * d_ptr->m_handleSize / 3);
517 QRectF r1(0, r.y(), size().width(), r.height());
518 QRectF r2(r.x(), 0, r.width(), r.y());
519 QRectF r3(r.x(), r.y() + r.height(), r.width(), size().height() - r.y() - r.height());
520 p.fillRect(r1, c);
521 p.fillRect(r2, c);
522 p.fillRect(r3, c);
523 p.setBrush(Qt::NoBrush);
524 p.save();
525 if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::CentralRadialHandle)
526 p.setPen(dragPen);
527 d_ptr->paintPoint(&p, d_ptr->m_centralRadial, d_ptr->m_handleSize);
528 p.restore();
529
530 const QRectF rect = QRectF(central.x() - d_ptr->m_radiusRadial * size().width(),
531 central.y() - d_ptr->m_radiusRadial * size().height(),
532 2 * d_ptr->m_radiusRadial * size().width(),
533 2 * d_ptr->m_radiusRadial * size().height());
534 QRegion region(r1.toRect());
535 region += r2.toRect();
536 region += r3.toRect();
537 p.setClipRegion(region);
538
539 p.drawEllipse(rect);
540 if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::RadiusRadialHandle) {
541 p.save();
542 p.setPen(dragPen);
543 QRectF rect = QRectF(central.x() - d_ptr->m_radiusRadial / d_ptr->m_radiusFactor * size().width(),
544 central.y() - d_ptr->m_radiusRadial / d_ptr->m_radiusFactor * size().height(),
545 2 * d_ptr->m_radiusRadial / d_ptr->m_radiusFactor * size().width(),
546 2 * d_ptr->m_radiusRadial / d_ptr->m_radiusFactor * size().height());
547 p.drawEllipse(rect);
548
549 p.restore();
550 }
551 p.restore();
552
553 p.save();
554 if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::FocalRadialHandle)
555 p.setPen(dragPen);
556 d_ptr->paintPoint(&p, d_ptr->m_focalRadial, 2 * d_ptr->m_handleSize / 3);
557 p.restore();
558 } else if (d_ptr->m_gradientType == QGradient::ConicalGradient) {
559 double radius = size().width();
560 if (size().height() < radius)
561 radius = size().height();
562 radius /= 2;
563 double corr = d_ptr->m_handleSize / 3;
564 radius -= corr;
565 QPointF central = d_ptr->toViewport(d_ptr->m_centralConical);
566
567 p.save();
568 p.setBrush(Qt::NoBrush);
569 QPen pen2(c);
570 pen2.setWidthF(2 * d_ptr->m_handleSize / 3);
571 p.setPen(pen2);
572 p.drawEllipse(d_ptr->pointRect(central, 2 * radius));
573 p.restore();
574
575 p.save();
576 p.setBrush(Qt::NoBrush);
577 int pointCount = 2;
578 for (int i = 0; i < pointCount; i++) {
579 const qreal angle = qDegreesToRadians(i * 180.0 / pointCount + d_ptr->m_angleConical);
580 const QPointF ray(qCos(angle) * size().width() / 2,
581 -qSin(angle) * size().height() / 2);
582 const double mod = hypot(ray.x(), ray.y());
583 p.drawLine(QPointF(central.x() + ray.x() * (radius - corr) / mod,
584 central.y() + ray.y() * (radius - corr) / mod),
585 QPointF(central.x() + ray.x() * (radius + corr) / mod,
586 central.y() + ray.y() * (radius + corr) / mod));
587 p.drawLine(QPointF(central.x() - ray.x() * (radius - corr) / mod,
588 central.y() - ray.y() * (radius - corr) / mod),
589 QPointF(central.x() - ray.x() * (radius + corr) / mod,
590 central.y() - ray.y() * (radius + corr) / mod));
591 }
592 if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::AngleConicalHandle) {
593 p.save();
594 p.setPen(dragPen);
595 const qreal angle = qDegreesToRadians(d_ptr->m_angleConical - d_ptr->m_angleOffset);
596 const QPointF ray(qCos(angle) * size().width() / 2,
597 -qSin(angle) * size().height() / 2);
598 const double mod = hypot(ray.x(), ray.y());
599 p.drawLine(QPointF(central.x() + ray.x() * (radius - corr) / mod,
600 central.y() + ray.y() * (radius - corr) / mod),
601 QPointF(central.x() + ray.x() * (radius + corr) / mod,
602 central.y() + ray.y() * (radius + corr) / mod));
603 p.restore();
604 }
605
606 p.restore();
607
608 p.save();
609 if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::CentralConicalHandle)
610 p.setPen(dragPen);
611 d_ptr->paintPoint(&p, d_ptr->m_centralConical, d_ptr->m_handleSize);
612 p.restore();
613
614 }
615
616 delete gradient;
617}
618
619void QtGradientWidget::setGradientStops(const QGradientStops &stops)
620{
621 d_ptr->m_gradientStops = stops;
622 update();
623}
624
625QGradientStops QtGradientWidget::gradientStops() const
626{
627 return d_ptr->m_gradientStops;
628}
629
630void QtGradientWidget::setGradientType(QGradient::Type type)
631{
632 if (type == QGradient::NoGradient)
633 return;
634 if (d_ptr->m_gradientType == type)
635 return;
636
637 d_ptr->m_gradientType = type;
638 update();
639}
640
641QGradient::Type QtGradientWidget::gradientType() const
642{
643 return d_ptr->m_gradientType;
644}
645
646void QtGradientWidget::setGradientSpread(QGradient::Spread spread)
647{
648 if (d_ptr->m_gradientSpread == spread)
649 return;
650
651 d_ptr->m_gradientSpread = spread;
652 update();
653}
654
655QGradient::Spread QtGradientWidget::gradientSpread() const
656{
657 return d_ptr->m_gradientSpread;
658}
659
660void QtGradientWidget::setStartLinear(QPointF point)
661{
662 if (d_ptr->m_startLinear == point)
663 return;
664
665 d_ptr->m_startLinear = d_ptr->checkRange(point);
666 update();
667}
668
669QPointF QtGradientWidget::startLinear() const
670{
671 return d_ptr->m_startLinear;
672}
673
674void QtGradientWidget::setEndLinear(QPointF point)
675{
676 if (d_ptr->m_endLinear == point)
677 return;
678
679 d_ptr->m_endLinear = d_ptr->checkRange(point);
680 update();
681}
682
683QPointF QtGradientWidget::endLinear() const
684{
685 return d_ptr->m_endLinear;
686}
687
688void QtGradientWidget::setCentralRadial(QPointF point)
689{
690 if (d_ptr->m_centralRadial == point)
691 return;
692
693 d_ptr->m_centralRadial = point;
694 update();
695}
696
697QPointF QtGradientWidget::centralRadial() const
698{
699 return d_ptr->m_centralRadial;
700}
701
702void QtGradientWidget::setFocalRadial(QPointF point)
703{
704 if (d_ptr->m_focalRadial == point)
705 return;
706
707 d_ptr->m_focalRadial = point;
708 update();
709}
710
711QPointF QtGradientWidget::focalRadial() const
712{
713 return d_ptr->m_focalRadial;
714}
715
716void QtGradientWidget::setRadiusRadial(qreal radius)
717{
718 if (d_ptr->m_radiusRadial == radius)
719 return;
720
721 d_ptr->m_radiusRadial = radius;
722 update();
723}
724
725qreal QtGradientWidget::radiusRadial() const
726{
727 return d_ptr->m_radiusRadial;
728}
729
730void QtGradientWidget::setCentralConical(QPointF point)
731{
732 if (d_ptr->m_centralConical == point)
733 return;
734
735 d_ptr->m_centralConical = point;
736 update();
737}
738
739QPointF QtGradientWidget::centralConical() const
740{
741 return d_ptr->m_centralConical;
742}
743
744void QtGradientWidget::setAngleConical(qreal angle)
745{
746 if (d_ptr->m_angleConical == angle)
747 return;
748
749 d_ptr->m_angleConical = angle;
750 update();
751}
752
753qreal QtGradientWidget::angleConical() const
754{
755 return d_ptr->m_angleConical;
756}
757
758QT_END_NAMESPACE
QtGradientWidgetPrivate::checkRange
QPointF checkRange(QPointF point) const
Definition qtgradientwidget.cpp:96
QtGradientWidgetPrivate::toViewport
QPointF toViewport(QPointF point) const
Definition qtgradientwidget.cpp:116
QtGradientWidgetPrivate::m_gradientSpread
QGradient::Spread m_gradientSpread
Definition qtgradientwidget.cpp:43
QtGradientWidgetPrivate::paintPoint
void paintPoint(QPainter *painter, QPointF point, double size) const
Definition qtgradientwidget.cpp:122
QtGradientWidgetPrivate::setAngleConical
void setAngleConical(double angle)
Definition qtgradientwidget.cpp:82
QtGradientWidgetPrivate::pointRect
QRectF pointRect(QPointF point, double size) const
Definition qtgradientwidget.cpp:91
QtGradientWidgetPrivate::correctAngle
double correctAngle(double angle) const
Definition qtgradientwidget.cpp:72
QT_BEGIN_NAMESPACE
Combined button and popup list for selecting options.
Definition qsequentialanimationgroup.cpp:47
qRadiansToDegrees
constexpr double qRadiansToDegrees(double radians)
Definition qmath.h:278