source: trunk/tools/shared/qtgradienteditor/qtgradientwidget.cpp@ 846

Last change on this file since 846 was 846, checked in by Dmitry A. Kuminov, 14 years ago

trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.
File size: 25.7 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4** All rights reserved.
5** Contact: Nokia Corporation ([email protected])
6**
7** This file is part of the tools applications of the Qt Toolkit.
8**
9** $QT_BEGIN_LICENSE:LGPL$
10** Commercial Usage
11** Licensees holding valid Qt Commercial licenses may use this file in
12** accordance with the Qt Commercial License Agreement provided with the
13** Software or, alternatively, in accordance with the terms contained in
14** a written agreement between you and Nokia.
15**
16** GNU Lesser General Public License Usage
17** Alternatively, this file may be used under the terms of the GNU Lesser
18** General Public License version 2.1 as published by the Free Software
19** Foundation and appearing in the file LICENSE.LGPL included in the
20** packaging of this file. Please review the following information to
21** ensure the GNU Lesser General Public License version 2.1 requirements
22** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
23**
24** In addition, as a special exception, Nokia gives you certain additional
25** rights. These rights are described in the Nokia Qt LGPL Exception
26** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
27**
28** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
36** If you have questions regarding the use of this file, please contact
37** Nokia at [email protected].
38** $QT_END_LICENSE$
39**
40****************************************************************************/
41
42#include "qtgradientwidget.h"
43#include <QtCore/QMap>
44#include <QtGui/QImage>
45#include <QtGui/QPainter>
46#include <QtGui/QScrollBar>
47#include <QtGui/QMouseEvent>
48
49#define _USE_MATH_DEFINES
50
51
52#include "math.h"
53
54#ifndef M_PI
55#define M_PI 3.14159265358979323846
56#endif
57
58QT_BEGIN_NAMESPACE
59
60class QtGradientWidgetPrivate
61{
62 QtGradientWidget *q_ptr;
63 Q_DECLARE_PUBLIC(QtGradientWidget)
64public:
65 QPointF fromViewport(const QPointF &point) const;
66 QPointF toViewport(const QPointF &point) const;
67// void setupDrag(QtGradientStop *stop, int x);
68
69 QPointF checkRange(const QPointF &point) const;
70 QRectF pointRect(const QPointF &point, double size) const;
71
72 double correctAngle(double angle) const;
73 void setAngleConical(double angle);
74
75 void paintPoint(QPainter *painter, const QPointF &point, double size) const;
76
77 double m_handleSize;
78 bool m_backgroundCheckered;
79
80 QGradientStops m_gradientStops;
81 QGradient::Type m_gradientType;
82 QGradient::Spread m_gradientSpread;
83 QPointF m_startLinear;
84 QPointF m_endLinear;
85 QPointF m_centralRadial;
86 QPointF m_focalRadial;
87 qreal m_radiusRadial;
88 QPointF m_centralConical;
89 qreal m_angleConical;
90
91 enum Handle {
92 NoHandle,
93 StartLinearHandle,
94 EndLinearHandle,
95 CentralRadialHandle,
96 FocalRadialHandle,
97 RadiusRadialHandle,
98 CentralConicalHandle,
99 AngleConicalHandle
100 };
101
102 Handle m_dragHandle;
103 QPointF m_dragOffset;
104 //double m_radiusOffset;
105 double m_radiusFactor;
106 double m_dragRadius;
107 double m_angleOffset;
108 double m_dragAngle;
109};
110
111double QtGradientWidgetPrivate::correctAngle(double angle) const
112{
113 double a = angle;
114 while (a >= 360)
115 a -= 360;
116 while (a < 0)
117 a += 360;
118 return a;
119}
120
121void QtGradientWidgetPrivate::setAngleConical(double angle)
122{
123 double a = correctAngle(angle);
124 if (m_angleConical == a)
125 return;
126 m_angleConical = a;
127 emit q_ptr->angleConicalChanged(m_angleConical);
128}
129
130QRectF QtGradientWidgetPrivate::pointRect(const QPointF &point, double size) const
131{
132 return QRectF(point.x() - size / 2, point.y() - size / 2, size, size);
133}
134
135QPointF QtGradientWidgetPrivate::checkRange(const QPointF &point) const
136{
137 QPointF p = point;
138 if (p.x() > 1)
139 p.setX(1);
140 else if (p.x() < 0)
141 p.setX(0);
142 if (p.y() > 1)
143 p.setY(1);
144 else if (p.y() < 0)
145 p.setY(0);
146 return p;
147}
148
149QPointF QtGradientWidgetPrivate::fromViewport(const QPointF &point) const
150{
151 QSize size = q_ptr->size();
152 return QPointF(point.x() / size.width(), point.y() / size.height());
153}
154
155QPointF QtGradientWidgetPrivate::toViewport(const QPointF &point) const
156{
157 QSize size = q_ptr->size();
158 return QPointF(point.x() * size.width(), point.y() * size.height());
159}
160
161void QtGradientWidgetPrivate::paintPoint(QPainter *painter, const QPointF &point, double size) const
162{
163 QPointF pf = toViewport(point);
164 QRectF rf = pointRect(pf, size);
165
166 QPen pen;
167 pen.setWidthF(1);
168 QColor alphaZero = Qt::white;
169 alphaZero.setAlpha(0);
170
171 painter->save();
172 painter->drawEllipse(rf);
173
174 /*
175 painter->save();
176
177 QLinearGradient lgV(0, rf.top(), 0, rf.bottom());
178 lgV.setColorAt(0, alphaZero);
179 lgV.setColorAt(0.25, Qt::white);
180 lgV.setColorAt(0.25, Qt::white);
181 lgV.setColorAt(1, alphaZero);
182 pen.setBrush(lgV);
183 painter->setPen(pen);
184
185 painter->drawLine(QPointF(pf.x(), rf.top()), QPointF(pf.x(), rf.bottom()));
186
187 QLinearGradient lgH(rf.left(), 0, rf.right(), 0);
188 lgH.setColorAt(0, alphaZero);
189 lgH.setColorAt(0.5, Qt::white);
190 lgH.setColorAt(1, alphaZero);
191 pen.setBrush(lgH);
192 painter->setPen(pen);
193
194 painter->drawLine(QPointF(rf.left(), pf.y()), QPointF(rf.right(), pf.y()));
195
196 painter->restore();
197 */
198
199 painter->restore();
200}
201
202/*
203void QtGradientWidgetPrivate::setupDrag(QtGradientStop *stop, int x)
204{
205 m_model->setCurrentStop(stop);
206
207 int viewportX = qRound(toViewport(stop->position()));
208 m_dragOffset = x - viewportX;
209
210 QList<QtGradientStop *> stops = m_stops;
211 m_stops.clear();
212 QListIterator<QtGradientStop *> itStop(stops);
213 while (itStop.hasNext()) {
214 QtGradientStop *s = itStop.next();
215 if (m_model->isSelected(s) || s == stop) {
216 m_dragStops[s] = s->position() - stop->position();
217 m_stops.append(s);
218 } else {
219 m_dragOriginal[s->position()] = s->color();
220 }
221 }
222 itStop.toFront();
223 while (itStop.hasNext()) {
224 QtGradientStop *s = itStop.next();
225 if (!m_model->isSelected(s))
226 m_stops.append(s);
227 }
228 m_stops.removeAll(stop);
229 m_stops.prepend(stop);
230}
231*/
232////////////////////////////
233
234QtGradientWidget::QtGradientWidget(QWidget *parent)
235 : QWidget(parent), d_ptr(new QtGradientWidgetPrivate)
236{
237 d_ptr->q_ptr = this;
238 d_ptr->m_backgroundCheckered = true;
239 d_ptr->m_handleSize = 20.0;
240 d_ptr->m_gradientType = QGradient::LinearGradient;
241 d_ptr->m_startLinear = QPointF(0, 0);
242 d_ptr->m_endLinear = QPointF(1, 1);
243 d_ptr->m_centralRadial = QPointF(0.5, 0.5);
244 d_ptr->m_focalRadial = QPointF(0.5, 0.5);
245 d_ptr->m_radiusRadial = 0.5;
246 d_ptr->m_centralConical = QPointF(0.5, 0.5);
247 d_ptr->m_angleConical = 0;
248 d_ptr->m_dragHandle = QtGradientWidgetPrivate::NoHandle;
249
250 setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred));
251}
252
253QtGradientWidget::~QtGradientWidget()
254{
255}
256
257QSize QtGradientWidget::sizeHint() const
258{
259 return QSize(176, 176);
260}
261
262QSize QtGradientWidget::minimumSizeHint() const
263{
264 return QSize(128, 128);
265}
266
267int QtGradientWidget::heightForWidth(int w) const
268{
269 return w;
270}
271
272void QtGradientWidget::setBackgroundCheckered(bool checkered)
273{
274 if (d_ptr->m_backgroundCheckered == checkered)
275 return;
276 d_ptr->m_backgroundCheckered = checkered;
277 update();
278}
279
280bool QtGradientWidget::isBackgroundCheckered() const
281{
282 return d_ptr->m_backgroundCheckered;
283}
284
285void QtGradientWidget::mousePressEvent(QMouseEvent *e)
286{
287 if (e->button() != Qt::LeftButton)
288 return;
289
290 QPoint p = e->pos();
291 if (d_ptr->m_gradientType == QGradient::LinearGradient) {
292 QPointF startPoint = d_ptr->toViewport(d_ptr->m_startLinear);
293 double x = p.x() - startPoint.x();
294 double y = p.y() - startPoint.y();
295
296 if ((d_ptr->m_handleSize * d_ptr->m_handleSize / 4) > (x * x + y * y)) {
297 d_ptr->m_dragHandle = QtGradientWidgetPrivate::StartLinearHandle;
298 d_ptr->m_dragOffset = QPointF(x, y);
299 update();
300 return;
301 }
302
303 QPointF endPoint = d_ptr->toViewport(d_ptr->m_endLinear);
304 x = p.x() - endPoint.x();
305 y = p.y() - endPoint.y();
306
307 if ((d_ptr->m_handleSize * d_ptr->m_handleSize / 4) > (x * x + y * y)) {
308 d_ptr->m_dragHandle = QtGradientWidgetPrivate::EndLinearHandle;
309 d_ptr->m_dragOffset = QPointF(x, y);
310 update();
311 return;
312 }
313 } else if (d_ptr->m_gradientType == QGradient::RadialGradient) {
314 QPointF focalPoint = d_ptr->toViewport(d_ptr->m_focalRadial);
315 double x = p.x() - focalPoint.x();
316 double y = p.y() - focalPoint.y();
317
318 if ((d_ptr->m_handleSize * d_ptr->m_handleSize / 9) > (x * x + y * y)) {
319 d_ptr->m_dragHandle = QtGradientWidgetPrivate::FocalRadialHandle;
320 d_ptr->m_dragOffset = QPointF(x, y);
321 update();
322 return;
323 }
324
325 QPointF centralPoint = d_ptr->toViewport(d_ptr->m_centralRadial);
326 x = p.x() - centralPoint.x();
327 y = p.y() - centralPoint.y();
328
329 if ((d_ptr->m_handleSize * d_ptr->m_handleSize / 4) > (x * x + y * y)) {
330 d_ptr->m_dragHandle = QtGradientWidgetPrivate::CentralRadialHandle;
331 d_ptr->m_dragOffset = QPointF(x, y);
332 update();
333 return;
334 }
335
336 QPointF central = d_ptr->toViewport(d_ptr->m_centralRadial);
337 QRectF r = d_ptr->pointRect(central, 2 * d_ptr->m_handleSize / 3);
338 QRectF r1(0, r.y(), size().width(), r.height());
339 QRectF r2(r.x(), 0, r.width(), r.y());
340 QRectF r3(r.x(), r.y() + r.height(), r.width(), size().height() - r.y() - r.height());
341 QPointF pF(p.x(), p.y());
342 if (r1.contains(pF) || r2.contains(pF) || r3.contains(pF)) {
343 x = pF.x() / size().width() - d_ptr->m_centralRadial.x();
344 y = pF.y() / size().height() - d_ptr->m_centralRadial.y();
345 double clickRadius = sqrt(x * x + y * y);
346 //d_ptr->m_radiusOffset = d_ptr->m_radiusRadial - clickRadius;
347 d_ptr->m_radiusFactor = d_ptr->m_radiusRadial / clickRadius;
348 if (d_ptr->m_radiusFactor == 0)
349 d_ptr->m_radiusFactor = 1;
350 d_ptr->m_dragRadius = d_ptr->m_radiusRadial;
351 d_ptr->m_dragHandle = QtGradientWidgetPrivate::RadiusRadialHandle;
352 mouseMoveEvent(e);
353 update();
354 return;
355 }
356 } else if (d_ptr->m_gradientType == QGradient::ConicalGradient) {
357 QPointF centralPoint = d_ptr->toViewport(d_ptr->m_centralConical);
358 double x = p.x() - centralPoint.x();
359 double y = p.y() - centralPoint.y();
360
361 if ((d_ptr->m_handleSize * d_ptr->m_handleSize / 4) > (x * x + y * y)) {
362 d_ptr->m_dragHandle = QtGradientWidgetPrivate::CentralConicalHandle;
363 d_ptr->m_dragOffset = QPointF(x, y);
364 update();
365 return;
366 }
367 double radius = size().width();
368 if (size().height() < radius)
369 radius = size().height();
370 radius /= 2;
371 double corr = d_ptr->m_handleSize / 3;
372 radius -= corr;
373 QPointF vp = d_ptr->toViewport(d_ptr->m_centralConical);
374 x = p.x() - vp.x();
375 y = p.y() - vp.y();
376 if (((radius - corr) * (radius - corr) < (x * x + y * y)) &&
377 ((radius + corr) * (radius + corr) > (x * x + y * y))) {
378 QPointF central = d_ptr->toViewport(d_ptr->m_centralConical);
379 QPointF current(e->pos().x(), e->pos().y());
380 x = current.x() - central.x();
381 y = current.y() - central.y();
382 x /= size().width() / 2;
383 y /= size().height() / 2;
384 double r = sqrt(x * x + y * y);
385
386 double arcSin = asin(y / r);
387 double arcCos = acos(x / r);
388
389 double angle = arcCos * 180 / M_PI;
390 if (arcSin > 0) {
391 angle = -angle;
392 }
393
394 d_ptr->m_angleOffset = d_ptr->m_angleConical - angle;
395 d_ptr->m_dragAngle = d_ptr->m_angleConical;
396 d_ptr->m_dragHandle = QtGradientWidgetPrivate::AngleConicalHandle;
397 update();
398 return;
399 }
400 }
401}
402
403void QtGradientWidget::mouseReleaseEvent(QMouseEvent *e)
404{
405 Q_UNUSED(e)
406 d_ptr->m_dragHandle = QtGradientWidgetPrivate::NoHandle;
407 update();
408}
409
410void QtGradientWidget::mouseMoveEvent(QMouseEvent *e)
411{
412 if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::NoHandle)
413 return;
414
415 QPointF newPos = QPointF((double)e->pos().x() - d_ptr->m_dragOffset.x(),
416 (double)e->pos().y() - d_ptr->m_dragOffset.y());
417 QPointF newPoint = d_ptr->fromViewport(newPos);
418 if (newPoint.x() < 0)
419 newPoint.setX(0);
420 else if (newPoint.x() > 1)
421 newPoint.setX(1);
422 if (newPoint.y() < 0)
423 newPoint.setY(0);
424 else if (newPoint.y() > 1)
425 newPoint.setY(1);
426
427 if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::StartLinearHandle) {
428 d_ptr->m_startLinear = newPoint;
429 emit startLinearChanged(newPoint);
430 } else if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::EndLinearHandle) {
431 d_ptr->m_endLinear = newPoint;
432 emit endLinearChanged(newPoint);
433 } else if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::CentralRadialHandle) {
434 d_ptr->m_centralRadial = newPoint;
435 emit centralRadialChanged(newPoint);
436 } else if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::FocalRadialHandle) {
437 d_ptr->m_focalRadial = newPoint;
438 emit focalRadialChanged(newPoint);
439 } else if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::RadiusRadialHandle) {
440 QPointF centralPoint = d_ptr->toViewport(d_ptr->m_centralRadial);
441 QPointF pF(e->pos().x(), e->pos().y());
442 double x = pF.x() - centralPoint.x();
443 double y = pF.y() - centralPoint.y();
444
445 if ((d_ptr->m_handleSize * d_ptr->m_handleSize / 4) > (x * x + y * y)) {
446 if (d_ptr->m_radiusRadial != d_ptr->m_dragRadius) {
447 d_ptr->m_radiusRadial = d_ptr->m_dragRadius;
448 emit radiusRadialChanged(d_ptr->m_radiusRadial);
449 }
450 } else {
451 x = pF.x() / size().width() - d_ptr->m_centralRadial.x();
452 y = pF.y() / size().height() - d_ptr->m_centralRadial.y();
453 double moveRadius = sqrt(x * x + y * y);
454 //double newRadius = moveRadius + d_ptr->m_radiusOffset;
455 double newRadius = moveRadius * d_ptr->m_radiusFactor;
456 if (newRadius > 2)
457 newRadius = 2;
458 d_ptr->m_radiusRadial = newRadius;
459 emit radiusRadialChanged(d_ptr->m_radiusRadial);
460 }
461 } else if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::CentralConicalHandle) {
462 d_ptr->m_centralConical = newPoint;
463 emit centralConicalChanged(newPoint);
464 } else if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::AngleConicalHandle) {
465 QPointF centralPoint = d_ptr->toViewport(d_ptr->m_centralConical);
466 QPointF pF(e->pos().x(), e->pos().y());
467 double x = pF.x() - centralPoint.x();
468 double y = pF.y() - centralPoint.y();
469
470 if ((d_ptr->m_handleSize * d_ptr->m_handleSize / 4) > (x * x + y * y)) {
471 if (d_ptr->m_angleConical != d_ptr->m_dragAngle) {
472 d_ptr->m_angleConical = d_ptr->m_dragAngle;
473 emit angleConicalChanged(d_ptr->m_angleConical);
474 }
475 } else {
476 QPointF central = d_ptr->toViewport(d_ptr->m_centralConical);
477 QPointF current = pF;
478 x = current.x() - central.x();
479 y = current.y() - central.y();
480 x /= size().width() / 2;
481 y /= size().height() / 2;
482 double r = sqrt(x * x + y * y);
483
484 double arcSin = asin(y / r);
485 double arcCos = acos(x / r);
486
487 double angle = arcCos * 180 / M_PI;
488 if (arcSin > 0) {
489 angle = -angle;
490 }
491
492 angle += d_ptr->m_angleOffset;
493
494 d_ptr->setAngleConical(angle);
495 }
496 }
497 update();
498}
499
500void QtGradientWidget::mouseDoubleClickEvent(QMouseEvent *e)
501{
502 mousePressEvent(e);
503}
504
505void QtGradientWidget::paintEvent(QPaintEvent *e)
506{
507 Q_UNUSED(e)
508
509 QPainter p(this);
510
511 if (d_ptr->m_backgroundCheckered) {
512 int pixSize = 40;
513 QPixmap pm(2 * pixSize, 2 * pixSize);
514
515 QPainter pmp(&pm);
516 pmp.fillRect(0, 0, pixSize, pixSize, Qt::white);
517 pmp.fillRect(pixSize, pixSize, pixSize, pixSize, Qt::white);
518 pmp.fillRect(0, pixSize, pixSize, pixSize, Qt::black);
519 pmp.fillRect(pixSize, 0, pixSize, pixSize, Qt::black);
520
521 p.setBrushOrigin((size().width() % pixSize + pixSize) / 2, (size().height() % pixSize + pixSize) / 2);
522 p.fillRect(rect(), pm);
523 p.setBrushOrigin(0, 0);
524 }
525
526 QGradient *gradient = 0;
527 switch (d_ptr->m_gradientType) {
528 case QGradient::LinearGradient:
529 gradient = new QLinearGradient(d_ptr->m_startLinear, d_ptr->m_endLinear);
530 break;
531 case QGradient::RadialGradient:
532 gradient = new QRadialGradient(d_ptr->m_centralRadial, d_ptr->m_radiusRadial, d_ptr->m_focalRadial);
533 break;
534 case QGradient::ConicalGradient:
535 gradient = new QConicalGradient(d_ptr->m_centralConical, d_ptr->m_angleConical);
536 break;
537 default:
538 break;
539 }
540 if (!gradient)
541 return;
542
543 gradient->setStops(d_ptr->m_gradientStops);
544 gradient->setSpread(d_ptr->m_gradientSpread);
545
546 p.save();
547 p.scale(size().width(), size().height());
548 p.fillRect(QRect(0, 0, 1, 1), *gradient);
549 p.restore();
550
551 p.setRenderHint(QPainter::Antialiasing);
552
553 QColor c = QColor::fromRgbF(0.5, 0.5, 0.5, 0.5);
554 QBrush br(c);
555 p.setBrush(br);
556 QPen pen(Qt::white);
557 pen.setWidthF(1);
558 p.setPen(pen);
559 QPen dragPen = pen;
560 dragPen.setWidthF(2);
561 if (d_ptr->m_gradientType == QGradient::LinearGradient) {
562 p.save();
563 if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::StartLinearHandle)
564 p.setPen(dragPen);
565 d_ptr->paintPoint(&p, d_ptr->m_startLinear, d_ptr->m_handleSize);
566 p.restore();
567
568 p.save();
569 if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::EndLinearHandle)
570 p.setPen(dragPen);
571 d_ptr->paintPoint(&p, d_ptr->m_endLinear, d_ptr->m_handleSize);
572 p.restore();
573 } else if (d_ptr->m_gradientType == QGradient::RadialGradient) {
574 QPointF central = d_ptr->toViewport(d_ptr->m_centralRadial);
575
576 p.save();
577 QRectF r = d_ptr->pointRect(central, 2 * d_ptr->m_handleSize / 3);
578 QRectF r1(0, r.y(), size().width(), r.height());
579 QRectF r2(r.x(), 0, r.width(), r.y());
580 QRectF r3(r.x(), r.y() + r.height(), r.width(), size().height() - r.y() - r.height());
581 p.fillRect(r1, c);
582 p.fillRect(r2, c);
583 p.fillRect(r3, c);
584 p.setBrush(Qt::NoBrush);
585 p.save();
586 if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::CentralRadialHandle)
587 p.setPen(dragPen);
588 d_ptr->paintPoint(&p, d_ptr->m_centralRadial, d_ptr->m_handleSize);
589 p.restore();
590
591 QRectF rect = QRectF(central.x() - d_ptr->m_radiusRadial * size().width(),
592 central.y() - d_ptr->m_radiusRadial * size().height(),
593 2 * d_ptr->m_radiusRadial * size().width(),
594 2 * d_ptr->m_radiusRadial * size().height());
595 p.setClipRect(r1);
596 p.setClipRect(r2, Qt::UniteClip);
597 p.setClipRect(r3, Qt::UniteClip);
598 p.drawEllipse(rect);
599 if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::RadiusRadialHandle) {
600 p.save();
601 p.setPen(dragPen);
602 QRectF rect = QRectF(central.x() - d_ptr->m_radiusRadial / d_ptr->m_radiusFactor * size().width(),
603 central.y() - d_ptr->m_radiusRadial / d_ptr->m_radiusFactor * size().height(),
604 2 * d_ptr->m_radiusRadial / d_ptr->m_radiusFactor * size().width(),
605 2 * d_ptr->m_radiusRadial / d_ptr->m_radiusFactor * size().height());
606 p.drawEllipse(rect);
607
608 p.restore();
609 }
610 p.restore();
611
612 p.save();
613 if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::FocalRadialHandle)
614 p.setPen(dragPen);
615 d_ptr->paintPoint(&p, d_ptr->m_focalRadial, 2 * d_ptr->m_handleSize / 3);
616 p.restore();
617 } else if (d_ptr->m_gradientType == QGradient::ConicalGradient) {
618 double radius = size().width();
619 if (size().height() < radius)
620 radius = size().height();
621 radius /= 2;
622 double corr = d_ptr->m_handleSize / 3;
623 radius -= corr;
624 QPointF central = d_ptr->toViewport(d_ptr->m_centralConical);
625
626 p.save();
627 p.setBrush(Qt::NoBrush);
628 QPen pen2(c);
629 pen2.setWidthF(2 * d_ptr->m_handleSize / 3);
630 p.setPen(pen2);
631 p.drawEllipse(d_ptr->pointRect(central, 2 * radius));
632 p.restore();
633
634 p.save();
635 p.setBrush(Qt::NoBrush);
636 int pointCount = 2;
637 for (int i = 0; i < pointCount; i++) {
638 QPointF ang(cos(M_PI * (i * 180.0 / pointCount + d_ptr->m_angleConical) / 180) * size().width() / 2,
639 -sin(M_PI * (i * 180.0 / pointCount + d_ptr->m_angleConical) / 180) * size().height() / 2);
640 double mod = sqrt(ang.x() * ang.x() + ang.y() * ang.y());
641 p.drawLine(QPointF(central.x() + ang.x() * (radius - corr) / mod,
642 central.y() + ang.y() * (radius - corr) / mod),
643 QPointF(central.x() + ang.x() * (radius + corr) / mod,
644 central.y() + ang.y() * (radius + corr) / mod));
645 p.drawLine(QPointF(central.x() - ang.x() * (radius - corr) / mod,
646 central.y() - ang.y() * (radius - corr) / mod),
647 QPointF(central.x() - ang.x() * (radius + corr) / mod,
648 central.y() - ang.y() * (radius + corr) / mod));
649 }
650 if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::AngleConicalHandle) {
651 p.save();
652 p.setPen(dragPen);
653 QPointF ang(cos(M_PI * (d_ptr->m_angleConical - d_ptr->m_angleOffset) / 180) * size().width() / 2,
654 -sin(M_PI * (d_ptr->m_angleConical - d_ptr->m_angleOffset) / 180) * size().height() / 2);
655 double mod = sqrt(ang.x() * ang.x() + ang.y() * ang.y());
656 p.drawLine(QPointF(central.x() + ang.x() * (radius - corr) / mod,
657 central.y() + ang.y() * (radius - corr) / mod),
658 QPointF(central.x() + ang.x() * (radius + corr) / mod,
659 central.y() + ang.y() * (radius + corr) / mod));
660 p.restore();
661 }
662
663 p.restore();
664
665 p.save();
666 if (d_ptr->m_dragHandle == QtGradientWidgetPrivate::CentralConicalHandle)
667 p.setPen(dragPen);
668 d_ptr->paintPoint(&p, d_ptr->m_centralConical, d_ptr->m_handleSize);
669 p.restore();
670
671 }
672
673 delete gradient;
674}
675
676void QtGradientWidget::setGradientStops(const QGradientStops &stops)
677{
678 d_ptr->m_gradientStops = stops;
679 update();
680}
681
682QGradientStops QtGradientWidget::gradientStops() const
683{
684 return d_ptr->m_gradientStops;
685}
686
687void QtGradientWidget::setGradientType(QGradient::Type type)
688{
689 if (type == QGradient::NoGradient)
690 return;
691 if (d_ptr->m_gradientType == type)
692 return;
693
694 d_ptr->m_gradientType = type;
695 update();
696}
697
698QGradient::Type QtGradientWidget::gradientType() const
699{
700 return d_ptr->m_gradientType;
701}
702
703void QtGradientWidget::setGradientSpread(QGradient::Spread spread)
704{
705 if (d_ptr->m_gradientSpread == spread)
706 return;
707
708 d_ptr->m_gradientSpread = spread;
709 update();
710}
711
712QGradient::Spread QtGradientWidget::gradientSpread() const
713{
714 return d_ptr->m_gradientSpread;
715}
716
717void QtGradientWidget::setStartLinear(const QPointF &point)
718{
719 if (d_ptr->m_startLinear == point)
720 return;
721
722 d_ptr->m_startLinear = d_ptr->checkRange(point);
723 update();
724}
725
726QPointF QtGradientWidget::startLinear() const
727{
728 return d_ptr->m_startLinear;
729}
730
731void QtGradientWidget::setEndLinear(const QPointF &point)
732{
733 if (d_ptr->m_endLinear == point)
734 return;
735
736 d_ptr->m_endLinear = d_ptr->checkRange(point);
737 update();
738}
739
740QPointF QtGradientWidget::endLinear() const
741{
742 return d_ptr->m_endLinear;
743}
744
745void QtGradientWidget::setCentralRadial(const QPointF &point)
746{
747 if (d_ptr->m_centralRadial == point)
748 return;
749
750 d_ptr->m_centralRadial = point;
751 update();
752}
753
754QPointF QtGradientWidget::centralRadial() const
755{
756 return d_ptr->m_centralRadial;
757}
758
759void QtGradientWidget::setFocalRadial(const QPointF &point)
760{
761 if (d_ptr->m_focalRadial == point)
762 return;
763
764 d_ptr->m_focalRadial = point;
765 update();
766}
767
768QPointF QtGradientWidget::focalRadial() const
769{
770 return d_ptr->m_focalRadial;
771}
772
773void QtGradientWidget::setRadiusRadial(qreal radius)
774{
775 if (d_ptr->m_radiusRadial == radius)
776 return;
777
778 d_ptr->m_radiusRadial = radius;
779 update();
780}
781
782qreal QtGradientWidget::radiusRadial() const
783{
784 return d_ptr->m_radiusRadial;
785}
786
787void QtGradientWidget::setCentralConical(const QPointF &point)
788{
789 if (d_ptr->m_centralConical == point)
790 return;
791
792 d_ptr->m_centralConical = point;
793 update();
794}
795
796QPointF QtGradientWidget::centralConical() const
797{
798 return d_ptr->m_centralConical;
799}
800
801void QtGradientWidget::setAngleConical(qreal angle)
802{
803 if (d_ptr->m_angleConical == angle)
804 return;
805
806 d_ptr->m_angleConical = angle;
807 update();
808}
809
810qreal QtGradientWidget::angleConical() const
811{
812 return d_ptr->m_angleConical;
813}
814
815QT_END_NAMESPACE
Note: See TracBrowser for help on using the repository browser.