source: trunk/tools/shared/qtgradienteditor/qtgradientstopscontroller.cpp@ 1113

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

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