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
qtgradientstopscontroller.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 "qtgradientstopscontroller_p.h"
6#include "ui_qtgradienteditor.h"
7#include "qtgradientstopsmodel_p.h"
8
9#include <QtCore/qtimer.h>
10
11QT_BEGIN_NAMESPACE
12
13using namespace Qt::StringLiterals;
14
15class QtGradientStopsControllerPrivate : public QObject
16{
17 Q_OBJECT
18 QtGradientStopsController *q_ptr = nullptr;
19 Q_DECLARE_PUBLIC(QtGradientStopsController)
20public:
21 using PositionColorMap = QMap<qreal, QColor>;
22 using PositionStopMap = QMap<qreal, QtGradientStop *>;
23
24 void setUi(Ui::QtGradientEditor *ui);
25
26 void slotHsvClicked();
27 void slotRgbClicked();
28
29 void slotCurrentStopChanged(QtGradientStop *stop);
30 void slotStopMoved(QtGradientStop *stop, qreal newPos);
31 void slotStopsSwapped(QtGradientStop *stop1, QtGradientStop *stop2);
32 void slotStopChanged(QtGradientStop *stop, QColor newColor);
33 void slotStopSelected(QtGradientStop *stop, bool selected);
34 void slotStopAdded(QtGradientStop *stop);
35 void slotStopRemoved(QtGradientStop *stop);
36 void slotUpdatePositionSpinBox();
37
38 void slotChangeColor(QColor color);
39 void slotChangeHueColor(QColor color);
40 void slotChangeSaturationColor(QColor color);
41 void slotChangeValueColor(QColor color);
42 void slotChangeAlphaColor(QColor color);
43 void slotChangeHue(int color);
44 void slotChangeSaturation(int color);
45 void slotChangeValue(int color);
46 void slotChangeAlpha(int color);
47 void slotChangePosition(double value);
48
49 void slotChangeZoom(int value);
50 void slotZoomIn();
51 void slotZoomOut();
52 void slotZoomAll();
53 void slotZoomChanged(double zoom);
54
55 void enableCurrent(bool enable);
56 void setColorSpinBoxes(QColor color);
57 PositionColorMap stopsData(const PositionStopMap &stops) const;
58 QGradientStops makeGradientStops(const PositionColorMap &data) const;
59 void updateZoom(double zoom);
60
61 QtGradientStopsModel *m_model = nullptr;
62 QColor::Spec m_spec = QColor::Hsv;
63
64 Ui::QtGradientEditor *m_ui = nullptr;
65};
66
67void QtGradientStopsControllerPrivate::setUi(Ui::QtGradientEditor *ui)
68{
69 m_ui = ui;
70
71 m_ui->hueColorLine->setColorComponent(QtColorLine::Hue);
72 m_ui->saturationColorLine->setColorComponent(QtColorLine::Saturation);
73 m_ui->valueColorLine->setColorComponent(QtColorLine::Value);
74 m_ui->alphaColorLine->setColorComponent(QtColorLine::Alpha);
75
76 m_model = new QtGradientStopsModel(this);
77 m_ui->gradientStopsWidget->setGradientStopsModel(m_model);
78 connect(m_model, &QtGradientStopsModel::currentStopChanged,
79 this, &QtGradientStopsControllerPrivate::slotCurrentStopChanged);
80 connect(m_model, &QtGradientStopsModel::stopMoved,
81 this, &QtGradientStopsControllerPrivate::slotStopMoved);
82 connect(m_model, &QtGradientStopsModel::stopsSwapped,
83 this, &QtGradientStopsControllerPrivate::slotStopsSwapped);
84 connect(m_model, &QtGradientStopsModel::stopChanged,
85 this, &QtGradientStopsControllerPrivate::slotStopChanged);
86 connect(m_model, &QtGradientStopsModel::stopSelected,
87 this, &QtGradientStopsControllerPrivate::slotStopSelected);
88 connect(m_model, &QtGradientStopsModel::stopAdded,
89 this, &QtGradientStopsControllerPrivate::slotStopAdded);
90 connect(m_model, &QtGradientStopsModel::stopRemoved,
91 this, &QtGradientStopsControllerPrivate::slotStopRemoved);
92
93 connect(m_ui->hueColorLine, &QtColorLine::colorChanged,
94 this, &QtGradientStopsControllerPrivate::slotChangeHueColor);
95 connect(m_ui->saturationColorLine, &QtColorLine::colorChanged,
96 this, &QtGradientStopsControllerPrivate::slotChangeSaturationColor);
97 connect(m_ui->valueColorLine, &QtColorLine::colorChanged,
98 this, &QtGradientStopsControllerPrivate::slotChangeValueColor);
99 connect(m_ui->alphaColorLine, &QtColorLine::colorChanged,
100 this, &QtGradientStopsControllerPrivate::slotChangeAlphaColor);
101 connect(m_ui->colorButton, &QtColorButton::colorChanged,
102 this, &QtGradientStopsControllerPrivate::slotChangeColor);
103
104 connect(m_ui->hueSpinBox, &QSpinBox::valueChanged,
105 this, &QtGradientStopsControllerPrivate::slotChangeHue);
106 connect(m_ui->saturationSpinBox, &QSpinBox::valueChanged,
107 this, &QtGradientStopsControllerPrivate::slotChangeSaturation);
108 connect(m_ui->valueSpinBox, &QSpinBox::valueChanged,
109 this, &QtGradientStopsControllerPrivate::slotChangeValue);
110 connect(m_ui->alphaSpinBox, &QSpinBox::valueChanged,
111 this, &QtGradientStopsControllerPrivate::slotChangeAlpha);
112
113 connect(m_ui->positionSpinBox, &QDoubleSpinBox::valueChanged,
114 this, &QtGradientStopsControllerPrivate::slotChangePosition);
115
116 connect(m_ui->zoomSpinBox, &QSpinBox::valueChanged,
117 this, &QtGradientStopsControllerPrivate::slotChangeZoom);
118 connect(m_ui->zoomInButton, &QToolButton::clicked,
119 this, &QtGradientStopsControllerPrivate::slotZoomIn);
120 connect(m_ui->zoomOutButton, &QToolButton::clicked,
121 this, &QtGradientStopsControllerPrivate::slotZoomOut);
122 connect(m_ui->zoomAllButton, &QToolButton::clicked,
123 this, &QtGradientStopsControllerPrivate::slotZoomAll);
124 connect(m_ui->gradientStopsWidget, &QtGradientStopsWidget::zoomChanged,
125 this, &QtGradientStopsControllerPrivate::slotZoomChanged);
126
127 connect(m_ui->hsvRadioButton, &QRadioButton::clicked,
128 this, &QtGradientStopsControllerPrivate::slotHsvClicked);
129 connect(m_ui->rgbRadioButton, &QRadioButton::clicked,
130 this, &QtGradientStopsControllerPrivate::slotRgbClicked);
131
132 enableCurrent(false);
133 m_ui->zoomInButton->setIcon(QIcon(":/qt-project.org/qtgradienteditor/images/zoomin.png"_L1));
134 m_ui->zoomOutButton->setIcon(QIcon(":/qt-project.org/qtgradienteditor/images/zoomout.png"_L1));
135 updateZoom(1);
136}
137
138void QtGradientStopsControllerPrivate::enableCurrent(bool enable)
139{
140 m_ui->positionLabel->setEnabled(enable);
141 m_ui->colorLabel->setEnabled(enable);
142 m_ui->hLabel->setEnabled(enable);
143 m_ui->sLabel->setEnabled(enable);
144 m_ui->vLabel->setEnabled(enable);
145 m_ui->aLabel->setEnabled(enable);
146 m_ui->hueLabel->setEnabled(enable);
147 m_ui->saturationLabel->setEnabled(enable);
148 m_ui->valueLabel->setEnabled(enable);
149 m_ui->alphaLabel->setEnabled(enable);
150
151 m_ui->positionSpinBox->setEnabled(enable);
152 m_ui->colorButton->setEnabled(enable);
153
154 m_ui->hueColorLine->setEnabled(enable);
155 m_ui->saturationColorLine->setEnabled(enable);
156 m_ui->valueColorLine->setEnabled(enable);
157 m_ui->alphaColorLine->setEnabled(enable);
158
159 m_ui->hueSpinBox->setEnabled(enable);
160 m_ui->saturationSpinBox->setEnabled(enable);
161 m_ui->valueSpinBox->setEnabled(enable);
162 m_ui->alphaSpinBox->setEnabled(enable);
163}
164
165QtGradientStopsControllerPrivate::PositionColorMap QtGradientStopsControllerPrivate::stopsData(const PositionStopMap &stops) const
166{
167 PositionColorMap data;
168 for (QtGradientStop *stop : stops)
169 data[stop->position()] = stop->color();
170 return data;
171}
172
173QGradientStops QtGradientStopsControllerPrivate::makeGradientStops(const PositionColorMap &data) const
174{
175 QGradientStops stops;
176 for (auto itData = data.cbegin(), cend = data.cend(); itData != cend; ++itData)
177 stops << std::pair<qreal, QColor>(itData.key(), itData.value());
178 return stops;
179}
180
181void QtGradientStopsControllerPrivate::updateZoom(double zoom)
182{
183 m_ui->gradientStopsWidget->setZoom(zoom);
184 m_ui->zoomSpinBox->blockSignals(true);
185 m_ui->zoomSpinBox->setValue(qRound(zoom * 100));
186 m_ui->zoomSpinBox->blockSignals(false);
187 bool zoomInEnabled = true;
188 bool zoomOutEnabled = true;
189 bool zoomAllEnabled = true;
190 if (zoom <= 1) {
191 zoomAllEnabled = false;
192 zoomOutEnabled = false;
193 } else if (zoom >= 100) {
194 zoomInEnabled = false;
195 }
196 m_ui->zoomInButton->setEnabled(zoomInEnabled);
197 m_ui->zoomOutButton->setEnabled(zoomOutEnabled);
198 m_ui->zoomAllButton->setEnabled(zoomAllEnabled);
199}
200
201void QtGradientStopsControllerPrivate::slotHsvClicked()
202{
203 QString h = QCoreApplication::translate("qdesigner_internal::QtGradientStopsController", "H");
204 QString s = QCoreApplication::translate("qdesigner_internal::QtGradientStopsController", "S");
205 QString v = QCoreApplication::translate("qdesigner_internal::QtGradientStopsController", "V");
206
207 m_ui->hLabel->setText(h);
208 m_ui->sLabel->setText(s);
209 m_ui->vLabel->setText(v);
210
211 h = QCoreApplication::translate("qdesigner_internal::QtGradientStopsController", "Hue");
212 s = QCoreApplication::translate("qdesigner_internal::QtGradientStopsController", "Sat");
213 v = QCoreApplication::translate("qdesigner_internal::QtGradientStopsController", "Val");
214
215 const QString hue = QCoreApplication::translate("qdesigner_internal::QtGradientStopsController", "Hue");
216 const QString saturation = QCoreApplication::translate("qdesigner_internal::QtGradientStopsController", "Saturation");
217 const QString value = QCoreApplication::translate("qdesigner_internal::QtGradientStopsController", "Value");
218
219 m_ui->hLabel->setToolTip(hue);
220 m_ui->hueLabel->setText(h);
221 m_ui->hueColorLine->setToolTip(hue);
222 m_ui->hueColorLine->setColorComponent(QtColorLine::Hue);
223
224 m_ui->sLabel->setToolTip(saturation);
225 m_ui->saturationLabel->setText(s);
226 m_ui->saturationColorLine->setToolTip(saturation);
227 m_ui->saturationColorLine->setColorComponent(QtColorLine::Saturation);
228
229 m_ui->vLabel->setToolTip(value);
230 m_ui->valueLabel->setText(v);
231 m_ui->valueColorLine->setToolTip(value);
232 m_ui->valueColorLine->setColorComponent(QtColorLine::Value);
233
234 setColorSpinBoxes(m_ui->colorButton->color());
235}
236
237void QtGradientStopsControllerPrivate::slotRgbClicked()
238{
239 QString r = QCoreApplication::translate("qdesigner_internal::QtGradientStopsController", "R");
240 QString g = QCoreApplication::translate("qdesigner_internal::QtGradientStopsController", "G");
241 QString b = QCoreApplication::translate("qdesigner_internal::QtGradientStopsController", "B");
242
243 m_ui->hLabel->setText(r);
244 m_ui->sLabel->setText(g);
245 m_ui->vLabel->setText(b);
246
247 QString red = QCoreApplication::translate("qdesigner_internal::QtGradientStopsController", "Red");
248 QString green = QCoreApplication::translate("qdesigner_internal::QtGradientStopsController", "Green");
249 QString blue = QCoreApplication::translate("qdesigner_internal::QtGradientStopsController", "Blue");
250
251 m_ui->hLabel->setToolTip(red);
252 m_ui->hueLabel->setText(red);
253 m_ui->hueColorLine->setToolTip(red);
254 m_ui->hueColorLine->setColorComponent(QtColorLine::Red);
255
256 m_ui->sLabel->setToolTip(green);
257 m_ui->saturationLabel->setText(green);
258 m_ui->saturationColorLine->setToolTip(green);
259 m_ui->saturationColorLine->setColorComponent(QtColorLine::Green);
260
261 m_ui->vLabel->setToolTip(blue);
262 m_ui->valueLabel->setText(blue);
263 m_ui->valueColorLine->setToolTip(blue);
264 m_ui->valueColorLine->setColorComponent(QtColorLine::Blue);
265
266 setColorSpinBoxes(m_ui->colorButton->color());
267}
268
269void QtGradientStopsControllerPrivate::setColorSpinBoxes(QColor color)
270{
271 m_ui->hueSpinBox->blockSignals(true);
272 m_ui->saturationSpinBox->blockSignals(true);
273 m_ui->valueSpinBox->blockSignals(true);
274 m_ui->alphaSpinBox->blockSignals(true);
275 if (m_ui->hsvRadioButton->isChecked()) {
276 if (m_ui->hueSpinBox->maximum() != 359)
277 m_ui->hueSpinBox->setMaximum(359);
278 if (m_ui->hueSpinBox->value() != color.hue())
279 m_ui->hueSpinBox->setValue(color.hue());
280 if (m_ui->saturationSpinBox->value() != color.saturation())
281 m_ui->saturationSpinBox->setValue(color.saturation());
282 if (m_ui->valueSpinBox->value() != color.value())
283 m_ui->valueSpinBox->setValue(color.value());
284 } else {
285 if (m_ui->hueSpinBox->maximum() != 255)
286 m_ui->hueSpinBox->setMaximum(255);
287 if (m_ui->hueSpinBox->value() != color.red())
288 m_ui->hueSpinBox->setValue(color.red());
289 if (m_ui->saturationSpinBox->value() != color.green())
290 m_ui->saturationSpinBox->setValue(color.green());
291 if (m_ui->valueSpinBox->value() != color.blue())
292 m_ui->valueSpinBox->setValue(color.blue());
293 }
294 m_ui->alphaSpinBox->setValue(color.alpha());
295 m_ui->hueSpinBox->blockSignals(false);
296 m_ui->saturationSpinBox->blockSignals(false);
297 m_ui->valueSpinBox->blockSignals(false);
298 m_ui->alphaSpinBox->blockSignals(false);
299}
300
301void QtGradientStopsControllerPrivate::slotCurrentStopChanged(QtGradientStop *stop)
302{
303 if (!stop) {
304 enableCurrent(false);
305 return;
306 }
307 enableCurrent(true);
308
309 QTimer::singleShot(0, this, &QtGradientStopsControllerPrivate::slotUpdatePositionSpinBox);
310
311 m_ui->colorButton->setColor(stop->color());
312 m_ui->hueColorLine->setColor(stop->color());
313 m_ui->saturationColorLine->setColor(stop->color());
314 m_ui->valueColorLine->setColor(stop->color());
315 m_ui->alphaColorLine->setColor(stop->color());
316 setColorSpinBoxes(stop->color());
317}
318
319void QtGradientStopsControllerPrivate::slotStopMoved(QtGradientStop *stop, qreal newPos)
320{
321 QTimer::singleShot(0, this, &QtGradientStopsControllerPrivate::slotUpdatePositionSpinBox);
322
323 PositionColorMap stops = stopsData(m_model->stops());
324 stops.remove(stop->position());
325 stops[newPos] = stop->color();
326
327 QGradientStops gradStops = makeGradientStops(stops);
328 emit q_ptr->gradientStopsChanged(gradStops);
329}
330
331void QtGradientStopsControllerPrivate::slotStopsSwapped(QtGradientStop *stop1, QtGradientStop *stop2)
332{
333 QTimer::singleShot(0, this, &QtGradientStopsControllerPrivate::slotUpdatePositionSpinBox);
334
335 PositionColorMap stops = stopsData(m_model->stops());
336 const qreal pos1 = stop1->position();
337 const qreal pos2 = stop2->position();
338 stops[pos1] = stop2->color();
339 stops[pos2] = stop1->color();
340
341 QGradientStops gradStops = makeGradientStops(stops);
342 emit q_ptr->gradientStopsChanged(gradStops);
343}
344
345void QtGradientStopsControllerPrivate::slotStopAdded(QtGradientStop *stop)
346{
347 PositionColorMap stops = stopsData(m_model->stops());
348 stops[stop->position()] = stop->color();
349
350 QGradientStops gradStops = makeGradientStops(stops);
351 emit q_ptr->gradientStopsChanged(gradStops);
352}
353
354void QtGradientStopsControllerPrivate::slotStopRemoved(QtGradientStop *stop)
355{
356 PositionColorMap stops = stopsData(m_model->stops());
357 stops.remove(stop->position());
358
359 QGradientStops gradStops = makeGradientStops(stops);
360 emit q_ptr->gradientStopsChanged(gradStops);
361}
362
363void QtGradientStopsControllerPrivate::slotStopChanged(QtGradientStop *stop,
364 QColor newColor)
365{
366 if (m_model->currentStop() == stop) {
367 m_ui->colorButton->setColor(newColor);
368 m_ui->hueColorLine->setColor(newColor);
369 m_ui->saturationColorLine->setColor(newColor);
370 m_ui->valueColorLine->setColor(newColor);
371 m_ui->alphaColorLine->setColor(newColor);
372 setColorSpinBoxes(newColor);
373 }
374
375 PositionColorMap stops = stopsData(m_model->stops());
376 stops[stop->position()] = newColor;
377
378 QGradientStops gradStops = makeGradientStops(stops);
379 emit q_ptr->gradientStopsChanged(gradStops);
380}
381
382void QtGradientStopsControllerPrivate::slotStopSelected(QtGradientStop *stop, bool selected)
383{
384 Q_UNUSED(stop);
385 Q_UNUSED(selected);
386 QTimer::singleShot(0, this, &QtGradientStopsControllerPrivate::slotUpdatePositionSpinBox);
387}
388
389void QtGradientStopsControllerPrivate::slotUpdatePositionSpinBox()
390{
391 QtGradientStop *current = m_model->currentStop();
392 if (!current)
393 return;
394
395 qreal min = 0.0;
396 qreal max = 1.0;
397 const qreal pos = current->position();
398
399 QtGradientStop *first = m_model->firstSelected();
400 QtGradientStop *last = m_model->lastSelected();
401
402 if (first && last) {
403 const qreal minPos = pos - first->position() - 0.0004999;
404 const qreal maxPos = pos + 1.0 - last->position() + 0.0004999;
405
406 if (max > maxPos)
407 max = maxPos;
408 if (min < minPos)
409 min = minPos;
410
411 if (first->position() == 0.0)
412 min = pos;
413 if (last->position() == 1.0)
414 max = pos;
415 }
416
417 const int spinMin = qRound(m_ui->positionSpinBox->minimum() * 1000);
418 const int spinMax = qRound(m_ui->positionSpinBox->maximum() * 1000);
419
420 const int newMin = qRound(min * 1000);
421 const int newMax = qRound(max * 1000);
422
423 m_ui->positionSpinBox->blockSignals(true);
424 if (spinMin != newMin || spinMax != newMax) {
425 m_ui->positionSpinBox->setRange(double(newMin) / 1000, double(newMax) / 1000);
426 }
427 if (m_ui->positionSpinBox->value() != pos)
428 m_ui->positionSpinBox->setValue(pos);
429 m_ui->positionSpinBox->blockSignals(false);
430}
431
432void QtGradientStopsControllerPrivate::slotChangeColor(QColor color)
433{
434 QtGradientStop *stop = m_model->currentStop();
435 if (!stop)
436 return;
437 m_model->changeStop(stop, color);
438 const auto stops = m_model->selectedStops();
439 for (QtGradientStop *s : stops) {
440 if (s != stop)
441 m_model->changeStop(s, color);
442 }
443}
444
445void QtGradientStopsControllerPrivate::slotChangeHueColor(QColor color)
446{
447 QtGradientStop *stop = m_model->currentStop();
448 if (!stop)
449 return;
450 m_model->changeStop(stop, color);
451 const auto stops = m_model->selectedStops();
452 for (QtGradientStop *s : stops) {
453 if (s != stop) {
454 QColor c = s->color();
455 if (m_ui->hsvRadioButton->isChecked())
456 c.setHsvF(color.hueF(), c.saturationF(), c.valueF(), c.alphaF());
457 else
458 c.setRgbF(color.redF(), c.greenF(), c.blueF(), c.alphaF());
459 m_model->changeStop(s, c);
460 }
461 }
462}
463
464void QtGradientStopsControllerPrivate::slotChangeHue(int color)
465{
466 QColor c = m_ui->hueColorLine->color();
467 if (m_ui->hsvRadioButton->isChecked())
468 c.setHsvF(qreal(color) / 360.0, c.saturationF(), c.valueF(), c.alphaF());
469 else
470 c.setRed(color);
471 slotChangeHueColor(c);
472}
473
474void QtGradientStopsControllerPrivate::slotChangeSaturationColor(QColor color)
475{
476 QtGradientStop *stop = m_model->currentStop();
477 if (!stop)
478 return;
479 m_model->changeStop(stop, color);
480 const auto stops = m_model->selectedStops();
481 for (QtGradientStop *s : stops) {
482 if (s != stop) {
483 QColor c = s->color();
484 if (m_ui->hsvRadioButton->isChecked()) {
485 c.setHsvF(c.hueF(), color.saturationF(), c.valueF(), c.alphaF());
486 int hue = c.hue();
487 if (hue == 360 || hue == -1)
488 c.setHsvF(0.0, c.saturationF(), c.valueF(), c.alphaF());
489 } else {
490 c.setRgbF(c.redF(), color.greenF(), c.blueF(), c.alphaF());
491 }
492 m_model->changeStop(s, c);
493 }
494 }
495}
496
497void QtGradientStopsControllerPrivate::slotChangeSaturation(int color)
498{
499 QColor c = m_ui->saturationColorLine->color();
500 if (m_ui->hsvRadioButton->isChecked())
501 c.setHsvF(c.hueF(), qreal(color) / 255, c.valueF(), c.alphaF());
502 else
503 c.setGreen(color);
504 slotChangeSaturationColor(c);
505}
506
507void QtGradientStopsControllerPrivate::slotChangeValueColor(QColor color)
508{
509 QtGradientStop *stop = m_model->currentStop();
510 if (!stop)
511 return;
512 m_model->changeStop(stop, color);
513 const auto stops = m_model->selectedStops();
514 for (QtGradientStop *s : stops) {
515 if (s != stop) {
516 QColor c = s->color();
517 if (m_ui->hsvRadioButton->isChecked()) {
518 c.setHsvF(c.hueF(), c.saturationF(), color.valueF(), c.alphaF());
519 int hue = c.hue();
520 if (hue == 360 || hue == -1)
521 c.setHsvF(0.0, c.saturationF(), c.valueF(), c.alphaF());
522 } else {
523 c.setRgbF(c.redF(), c.greenF(), color.blueF(), c.alphaF());
524 }
525 m_model->changeStop(s, c);
526 }
527 }
528}
529
530void QtGradientStopsControllerPrivate::slotChangeValue(int color)
531{
532 QColor c = m_ui->valueColorLine->color();
533 if (m_ui->hsvRadioButton->isChecked())
534 c.setHsvF(c.hueF(), c.saturationF(), qreal(color) / 255, c.alphaF());
535 else
536 c.setBlue(color);
537 slotChangeValueColor(c);
538}
539
540void QtGradientStopsControllerPrivate::slotChangeAlphaColor(QColor color)
541{
542 QtGradientStop *stop = m_model->currentStop();
543 if (!stop)
544 return;
545 m_model->changeStop(stop, color);
546 const auto stops = m_model->selectedStops();
547 for (QtGradientStop *s : stops) {
548 if (s != stop) {
549 QColor c = s->color();
550 if (m_ui->hsvRadioButton->isChecked()) {
551 c.setHsvF(c.hueF(), c.saturationF(), c.valueF(), color.alphaF());
552 int hue = c.hue();
553 if (hue == 360 || hue == -1)
554 c.setHsvF(0.0, c.saturationF(), c.valueF(), c.alphaF());
555 } else {
556 c.setRgbF(c.redF(), c.greenF(), c.blueF(), color.alphaF());
557 }
558 m_model->changeStop(s, c);
559 }
560 }
561}
562
563void QtGradientStopsControllerPrivate::slotChangeAlpha(int color)
564{
565 QColor c = m_ui->alphaColorLine->color();
566 if (m_ui->hsvRadioButton->isChecked())
567 c.setHsvF(c.hueF(), c.saturationF(), c.valueF(), qreal(color) / 255);
568 else
569 c.setAlpha(color);
570 slotChangeAlphaColor(c);
571}
572
573void QtGradientStopsControllerPrivate::slotChangePosition(double value)
574{
575 QtGradientStop *stop = m_model->currentStop();
576 if (!stop)
577 return;
578
579 m_model->moveStops(value);
580}
581
582void QtGradientStopsControllerPrivate::slotChangeZoom(int value)
583{
584 updateZoom(value / 100.0);
585}
586
587void QtGradientStopsControllerPrivate::slotZoomIn()
588{
589 double newZoom = m_ui->gradientStopsWidget->zoom() * 2;
590 if (newZoom > 100)
591 newZoom = 100;
592 updateZoom(newZoom);
593}
594
595void QtGradientStopsControllerPrivate::slotZoomOut()
596{
597 double newZoom = m_ui->gradientStopsWidget->zoom() / 2;
598 if (newZoom < 1)
599 newZoom = 1;
600 updateZoom(newZoom);
601}
602
607
612
613QtGradientStopsController::QtGradientStopsController(QObject *parent)
614 : QObject(parent), d_ptr(new QtGradientStopsControllerPrivate())
615{
616 d_ptr->q_ptr = this;
617}
618
619void QtGradientStopsController::setUi(Ui::QtGradientEditor *ui)
620{
621 d_ptr->setUi(ui);
622}
623
627
628void QtGradientStopsController::setGradientStops(const QGradientStops &stops)
629{
630 d_ptr->m_model->clear();
631 QtGradientStop *first = nullptr;
632 for (const std::pair<qreal, QColor> &pair : stops) {
633 QtGradientStop *stop = d_ptr->m_model->addStop(pair.first, pair.second);
634 if (!first)
635 first = stop;
636 }
637 if (first)
638 d_ptr->m_model->setCurrentStop(first);
639}
640
641QGradientStops QtGradientStopsController::gradientStops() const
642{
643 QGradientStops stops;
644 const auto stopsList = d_ptr->m_model->stops().values();
645 for (const QtGradientStop *stop : stopsList)
646 stops.append({stop->position(), stop->color()});
647 return stops;
648}
649
650QColor::Spec QtGradientStopsController::spec() const
651{
652 return d_ptr->m_spec;
653}
654
655void QtGradientStopsController::setSpec(QColor::Spec spec)
656{
657 if (d_ptr->m_spec == spec)
658 return;
659
660 d_ptr->m_spec = spec;
661 if (d_ptr->m_spec == QColor::Rgb) {
662 d_ptr->m_ui->rgbRadioButton->setChecked(true);
663 d_ptr->slotRgbClicked();
664 } else {
665 d_ptr->m_ui->hsvRadioButton->setChecked(true);
666 d_ptr->slotHsvClicked();
667 }
668}
669
670QT_END_NAMESPACE
671
672#include "qtgradientstopscontroller.moc"
QtGradientStopsControllerPrivate::makeGradientStops
QGradientStops makeGradientStops(const PositionColorMap &data) const
Definition qtgradientstopscontroller.cpp:173
QtGradientStopsControllerPrivate::stopsData
PositionColorMap stopsData(const PositionStopMap &stops) const
Definition qtgradientstopscontroller.cpp:165
QtGradientStopsControllerPrivate::slotStopChanged
void slotStopChanged(QtGradientStop *stop, QColor newColor)
Definition qtgradientstopscontroller.cpp:363
QtGradientStopsControllerPrivate::slotCurrentStopChanged
void slotCurrentStopChanged(QtGradientStop *stop)
Definition qtgradientstopscontroller.cpp:301
QtGradientStopsControllerPrivate::slotStopsSwapped
void slotStopsSwapped(QtGradientStop *stop1, QtGradientStop *stop2)
Definition qtgradientstopscontroller.cpp:331
QtGradientStopsControllerPrivate::slotStopSelected
void slotStopSelected(QtGradientStop *stop, bool selected)
Definition qtgradientstopscontroller.cpp:382
QtGradientStopsControllerPrivate::slotStopMoved
void slotStopMoved(QtGradientStop *stop, qreal newPos)
Definition qtgradientstopscontroller.cpp:319
QtGradientStopsController::setUi
void setUi(Ui::QtGradientEditor *editor)
Definition qtgradientstopscontroller.cpp:619
QtGradientStopsController::setGradientStops
void setGradientStops(const QGradientStops &stops)
Definition qtgradientstopscontroller.cpp:628
QtGradientStopsModel::stopSelected
void stopSelected(QtGradientStop *stop, bool selected)
QtGradientStopsModel::changeStop
void changeStop(QtGradientStop *stop, QColor newColor)
Definition qtgradientstopsmodel.cpp:226
QtGradientStopsModel::currentStop
QtGradientStop * currentStop() const
Definition qtgradientstopsmodel.cpp:135
QtGradientStopsModel::stopChanged
void stopChanged(QtGradientStop *stop, const QColor &newColor)
QtGradientStopsModel::firstSelected
QtGradientStop * firstSelected() const
Definition qtgradientstopsmodel.cpp:266
QtGradientStopsModel::moveStops
void moveStops(double newPosition)
Definition qtgradientstopsmodel.cpp:304
QtGradientStopsModel::stopRemoved
void stopRemoved(QtGradientStop *stop)
QtGradientStopsModel::currentStopChanged
void currentStopChanged(QtGradientStop *stop)
QtGradientStopsModel::stopsSwapped
void stopsSwapped(QtGradientStop *stop1, QtGradientStop *stop2)
QtGradientStopsModel::lastSelected
QtGradientStop * lastSelected() const
Definition qtgradientstopsmodel.cpp:279
QT_BEGIN_NAMESPACE
Combined button and popup list for selecting options.
Definition qsequentialanimationgroup.cpp:47