Alessandro Bonazzi
8c43d5cf2f
Files correlati : cg0.exe cg0700a.msk cg0700b.msk cg3.exe cg4.exe Bug : Commento: Merge 1.0 libraries
725 lines
26 KiB
C++
725 lines
26 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2015 The Qt Company Ltd.
|
|
** Contact: http://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the tools applications of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see http://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at http://www.qt.io/contact-us.
|
|
**
|
|
** GNU Lesser General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU Lesser
|
|
** General Public License version 2.1 or version 3 as published by the Free
|
|
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
|
|
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
|
|
** following information to ensure the GNU Lesser General Public License
|
|
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
|
|
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
|
**
|
|
** As a special exception, The Qt Company gives you certain additional
|
|
** rights. These rights are described in The Qt Company LGPL Exception
|
|
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 3.0 as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.GPL included in the
|
|
** packaging of this file. Please review the following information to
|
|
** ensure the GNU General Public License version 3.0 requirements will be
|
|
** met: http://www.gnu.org/copyleft/gpl.html.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#include "qtgradientstopscontroller.h"
|
|
#include "ui_qtgradienteditor.h"
|
|
#include "qtgradientstopsmodel.h"
|
|
|
|
#include <QtCore/QTimer>
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
class QtGradientStopsControllerPrivate
|
|
{
|
|
QtGradientStopsController *q_ptr;
|
|
Q_DECLARE_PUBLIC(QtGradientStopsController)
|
|
public:
|
|
typedef QMap<qreal, QColor> PositionColorMap;
|
|
typedef QMap<qreal, QtGradientStop *> PositionStopMap;
|
|
|
|
void slotHsvClicked();
|
|
void slotRgbClicked();
|
|
|
|
void slotCurrentStopChanged(QtGradientStop *stop);
|
|
void slotStopMoved(QtGradientStop *stop, qreal newPos);
|
|
void slotStopsSwapped(QtGradientStop *stop1, QtGradientStop *stop2);
|
|
void slotStopChanged(QtGradientStop *stop, const QColor &newColor);
|
|
void slotStopSelected(QtGradientStop *stop, bool selected);
|
|
void slotStopAdded(QtGradientStop *stop);
|
|
void slotStopRemoved(QtGradientStop *stop);
|
|
void slotUpdatePositionSpinBox();
|
|
|
|
void slotChangeColor(const QColor &color);
|
|
void slotChangeHue(const QColor &color);
|
|
void slotChangeSaturation(const QColor &color);
|
|
void slotChangeValue(const QColor &color);
|
|
void slotChangeAlpha(const QColor &color);
|
|
void slotChangeHue(int color);
|
|
void slotChangeSaturation(int color);
|
|
void slotChangeValue(int color);
|
|
void slotChangeAlpha(int color);
|
|
void slotChangePosition(double value);
|
|
|
|
void slotChangeZoom(int value);
|
|
void slotZoomIn();
|
|
void slotZoomOut();
|
|
void slotZoomAll();
|
|
void slotZoomChanged(double zoom);
|
|
|
|
void enableCurrent(bool enable);
|
|
void setColorSpinBoxes(const QColor &color);
|
|
PositionColorMap stopsData(const PositionStopMap &stops) const;
|
|
QGradientStops makeGradientStops(const PositionColorMap &data) const;
|
|
void updateZoom(double zoom);
|
|
|
|
QtGradientStopsModel *m_model;
|
|
QColor::Spec m_spec;
|
|
|
|
Ui::QtGradientEditor *m_ui;
|
|
};
|
|
|
|
void QtGradientStopsControllerPrivate::enableCurrent(bool enable)
|
|
{
|
|
m_ui->positionLabel->setEnabled(enable);
|
|
m_ui->colorLabel->setEnabled(enable);
|
|
m_ui->hLabel->setEnabled(enable);
|
|
m_ui->sLabel->setEnabled(enable);
|
|
m_ui->vLabel->setEnabled(enable);
|
|
m_ui->aLabel->setEnabled(enable);
|
|
m_ui->hueLabel->setEnabled(enable);
|
|
m_ui->saturationLabel->setEnabled(enable);
|
|
m_ui->valueLabel->setEnabled(enable);
|
|
m_ui->alphaLabel->setEnabled(enable);
|
|
|
|
m_ui->positionSpinBox->setEnabled(enable);
|
|
m_ui->colorButton->setEnabled(enable);
|
|
|
|
m_ui->hueColorLine->setEnabled(enable);
|
|
m_ui->saturationColorLine->setEnabled(enable);
|
|
m_ui->valueColorLine->setEnabled(enable);
|
|
m_ui->alphaColorLine->setEnabled(enable);
|
|
|
|
m_ui->hueSpinBox->setEnabled(enable);
|
|
m_ui->saturationSpinBox->setEnabled(enable);
|
|
m_ui->valueSpinBox->setEnabled(enable);
|
|
m_ui->alphaSpinBox->setEnabled(enable);
|
|
}
|
|
|
|
QtGradientStopsControllerPrivate::PositionColorMap QtGradientStopsControllerPrivate::stopsData(const PositionStopMap &stops) const
|
|
{
|
|
PositionColorMap data;
|
|
PositionStopMap::ConstIterator itStop = stops.constBegin();
|
|
while (itStop != stops.constEnd()) {
|
|
QtGradientStop *stop = itStop.value();
|
|
data[stop->position()] = stop->color();
|
|
|
|
++itStop;
|
|
}
|
|
return data;
|
|
}
|
|
|
|
QGradientStops QtGradientStopsControllerPrivate::makeGradientStops(const PositionColorMap &data) const
|
|
{
|
|
QGradientStops stops;
|
|
PositionColorMap::ConstIterator itData = data.constBegin();
|
|
while (itData != data.constEnd()) {
|
|
stops << QPair<qreal, QColor>(itData.key(), itData.value());
|
|
|
|
++itData;
|
|
}
|
|
return stops;
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::updateZoom(double zoom)
|
|
{
|
|
m_ui->gradientStopsWidget->setZoom(zoom);
|
|
m_ui->zoomSpinBox->blockSignals(true);
|
|
m_ui->zoomSpinBox->setValue(qRound(zoom * 100));
|
|
m_ui->zoomSpinBox->blockSignals(false);
|
|
bool zoomInEnabled = true;
|
|
bool zoomOutEnabled = true;
|
|
bool zoomAllEnabled = true;
|
|
if (zoom <= 1) {
|
|
zoomAllEnabled = false;
|
|
zoomOutEnabled = false;
|
|
} else if (zoom >= 100) {
|
|
zoomInEnabled = false;
|
|
}
|
|
m_ui->zoomInButton->setEnabled(zoomInEnabled);
|
|
m_ui->zoomOutButton->setEnabled(zoomOutEnabled);
|
|
m_ui->zoomAllButton->setEnabled(zoomAllEnabled);
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotHsvClicked()
|
|
{
|
|
QString h = QApplication::translate("qdesigner_internal::QtGradientStopsController", "H", 0, QApplication::UnicodeUTF8);
|
|
QString s = QApplication::translate("qdesigner_internal::QtGradientStopsController", "S", 0, QApplication::UnicodeUTF8);
|
|
QString v = QApplication::translate("qdesigner_internal::QtGradientStopsController", "V", 0, QApplication::UnicodeUTF8);
|
|
|
|
m_ui->hLabel->setText(h);
|
|
m_ui->sLabel->setText(s);
|
|
m_ui->vLabel->setText(v);
|
|
|
|
h = QApplication::translate("qdesigner_internal::QtGradientStopsController", "Hue", 0, QApplication::UnicodeUTF8);
|
|
s = QApplication::translate("qdesigner_internal::QtGradientStopsController", "Sat", 0, QApplication::UnicodeUTF8);
|
|
v = QApplication::translate("qdesigner_internal::QtGradientStopsController", "Val", 0, QApplication::UnicodeUTF8);
|
|
|
|
const QString hue = QApplication::translate("qdesigner_internal::QtGradientStopsController", "Hue", 0, QApplication::UnicodeUTF8);
|
|
const QString saturation = QApplication::translate("qdesigner_internal::QtGradientStopsController", "Saturation", 0, QApplication::UnicodeUTF8);
|
|
const QString value = QApplication::translate("qdesigner_internal::QtGradientStopsController", "Value", 0, QApplication::UnicodeUTF8);
|
|
|
|
m_ui->hLabel->setToolTip(hue);
|
|
m_ui->hueLabel->setText(h);
|
|
m_ui->hueColorLine->setToolTip(hue);
|
|
m_ui->hueColorLine->setColorComponent(QtColorLine::Hue);
|
|
|
|
m_ui->sLabel->setToolTip(saturation);
|
|
m_ui->saturationLabel->setText(s);
|
|
m_ui->saturationColorLine->setToolTip(saturation);
|
|
m_ui->saturationColorLine->setColorComponent(QtColorLine::Saturation);
|
|
|
|
m_ui->vLabel->setToolTip(value);
|
|
m_ui->valueLabel->setText(v);
|
|
m_ui->valueColorLine->setToolTip(value);
|
|
m_ui->valueColorLine->setColorComponent(QtColorLine::Value);
|
|
|
|
setColorSpinBoxes(m_ui->colorButton->color());
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotRgbClicked()
|
|
{
|
|
QString r = QApplication::translate("qdesigner_internal::QtGradientStopsController", "R", 0, QApplication::UnicodeUTF8);
|
|
QString g = QApplication::translate("qdesigner_internal::QtGradientStopsController", "G", 0, QApplication::UnicodeUTF8);
|
|
QString b = QApplication::translate("qdesigner_internal::QtGradientStopsController", "B", 0, QApplication::UnicodeUTF8);
|
|
|
|
m_ui->hLabel->setText(r);
|
|
m_ui->sLabel->setText(g);
|
|
m_ui->vLabel->setText(b);
|
|
|
|
QString red = QApplication::translate("qdesigner_internal::QtGradientStopsController", "Red", 0, QApplication::UnicodeUTF8);
|
|
QString green = QApplication::translate("qdesigner_internal::QtGradientStopsController", "Green", 0, QApplication::UnicodeUTF8);
|
|
QString blue = QApplication::translate("qdesigner_internal::QtGradientStopsController", "Blue", 0, QApplication::UnicodeUTF8);
|
|
|
|
m_ui->hLabel->setToolTip(red);
|
|
m_ui->hueLabel->setText(red);
|
|
m_ui->hueColorLine->setToolTip(red);
|
|
m_ui->hueColorLine->setColorComponent(QtColorLine::Red);
|
|
|
|
m_ui->sLabel->setToolTip(green);
|
|
m_ui->saturationLabel->setText(green);
|
|
m_ui->saturationColorLine->setToolTip(green);
|
|
m_ui->saturationColorLine->setColorComponent(QtColorLine::Green);
|
|
|
|
m_ui->vLabel->setToolTip(blue);
|
|
m_ui->valueLabel->setText(blue);
|
|
m_ui->valueColorLine->setToolTip(blue);
|
|
m_ui->valueColorLine->setColorComponent(QtColorLine::Blue);
|
|
|
|
setColorSpinBoxes(m_ui->colorButton->color());
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::setColorSpinBoxes(const QColor &color)
|
|
{
|
|
m_ui->hueSpinBox->blockSignals(true);
|
|
m_ui->saturationSpinBox->blockSignals(true);
|
|
m_ui->valueSpinBox->blockSignals(true);
|
|
m_ui->alphaSpinBox->blockSignals(true);
|
|
if (m_ui->hsvRadioButton->isChecked()) {
|
|
if (m_ui->hueSpinBox->maximum() != 359)
|
|
m_ui->hueSpinBox->setMaximum(359);
|
|
if (m_ui->hueSpinBox->value() != color.hue())
|
|
m_ui->hueSpinBox->setValue(color.hue());
|
|
if (m_ui->saturationSpinBox->value() != color.saturation())
|
|
m_ui->saturationSpinBox->setValue(color.saturation());
|
|
if (m_ui->valueSpinBox->value() != color.value())
|
|
m_ui->valueSpinBox->setValue(color.value());
|
|
} else {
|
|
if (m_ui->hueSpinBox->maximum() != 255)
|
|
m_ui->hueSpinBox->setMaximum(255);
|
|
if (m_ui->hueSpinBox->value() != color.red())
|
|
m_ui->hueSpinBox->setValue(color.red());
|
|
if (m_ui->saturationSpinBox->value() != color.green())
|
|
m_ui->saturationSpinBox->setValue(color.green());
|
|
if (m_ui->valueSpinBox->value() != color.blue())
|
|
m_ui->valueSpinBox->setValue(color.blue());
|
|
}
|
|
m_ui->alphaSpinBox->setValue(color.alpha());
|
|
m_ui->hueSpinBox->blockSignals(false);
|
|
m_ui->saturationSpinBox->blockSignals(false);
|
|
m_ui->valueSpinBox->blockSignals(false);
|
|
m_ui->alphaSpinBox->blockSignals(false);
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotCurrentStopChanged(QtGradientStop *stop)
|
|
{
|
|
if (!stop) {
|
|
enableCurrent(false);
|
|
return;
|
|
}
|
|
enableCurrent(true);
|
|
|
|
QTimer::singleShot(0, q_ptr, SLOT(slotUpdatePositionSpinBox()));
|
|
|
|
m_ui->colorButton->setColor(stop->color());
|
|
m_ui->hueColorLine->setColor(stop->color());
|
|
m_ui->saturationColorLine->setColor(stop->color());
|
|
m_ui->valueColorLine->setColor(stop->color());
|
|
m_ui->alphaColorLine->setColor(stop->color());
|
|
setColorSpinBoxes(stop->color());
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotStopMoved(QtGradientStop *stop, qreal newPos)
|
|
{
|
|
QTimer::singleShot(0, q_ptr, SLOT(slotUpdatePositionSpinBox()));
|
|
|
|
PositionColorMap stops = stopsData(m_model->stops());
|
|
stops.remove(stop->position());
|
|
stops[newPos] = stop->color();
|
|
|
|
QGradientStops gradStops = makeGradientStops(stops);
|
|
emit q_ptr->gradientStopsChanged(gradStops);
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotStopsSwapped(QtGradientStop *stop1, QtGradientStop *stop2)
|
|
{
|
|
QTimer::singleShot(0, q_ptr, SLOT(slotUpdatePositionSpinBox()));
|
|
|
|
PositionColorMap stops = stopsData(m_model->stops());
|
|
const qreal pos1 = stop1->position();
|
|
const qreal pos2 = stop2->position();
|
|
stops[pos1] = stop2->color();
|
|
stops[pos2] = stop1->color();
|
|
|
|
QGradientStops gradStops = makeGradientStops(stops);
|
|
emit q_ptr->gradientStopsChanged(gradStops);
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotStopAdded(QtGradientStop *stop)
|
|
{
|
|
PositionColorMap stops = stopsData(m_model->stops());
|
|
stops[stop->position()] = stop->color();
|
|
|
|
QGradientStops gradStops = makeGradientStops(stops);
|
|
emit q_ptr->gradientStopsChanged(gradStops);
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotStopRemoved(QtGradientStop *stop)
|
|
{
|
|
PositionColorMap stops = stopsData(m_model->stops());
|
|
stops.remove(stop->position());
|
|
|
|
QGradientStops gradStops = makeGradientStops(stops);
|
|
emit q_ptr->gradientStopsChanged(gradStops);
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotStopChanged(QtGradientStop *stop, const QColor &newColor)
|
|
{
|
|
if (m_model->currentStop() == stop) {
|
|
m_ui->colorButton->setColor(newColor);
|
|
m_ui->hueColorLine->setColor(newColor);
|
|
m_ui->saturationColorLine->setColor(newColor);
|
|
m_ui->valueColorLine->setColor(newColor);
|
|
m_ui->alphaColorLine->setColor(newColor);
|
|
setColorSpinBoxes(newColor);
|
|
}
|
|
|
|
PositionColorMap stops = stopsData(m_model->stops());
|
|
stops[stop->position()] = newColor;
|
|
|
|
QGradientStops gradStops = makeGradientStops(stops);
|
|
emit q_ptr->gradientStopsChanged(gradStops);
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotStopSelected(QtGradientStop *stop, bool selected)
|
|
{
|
|
Q_UNUSED(stop)
|
|
Q_UNUSED(selected)
|
|
QTimer::singleShot(0, q_ptr, SLOT(slotUpdatePositionSpinBox()));
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotUpdatePositionSpinBox()
|
|
{
|
|
QtGradientStop *current = m_model->currentStop();
|
|
if (!current)
|
|
return;
|
|
|
|
qreal min = 0.0;
|
|
qreal max = 1.0;
|
|
const qreal pos = current->position();
|
|
|
|
QtGradientStop *first = m_model->firstSelected();
|
|
QtGradientStop *last = m_model->lastSelected();
|
|
|
|
if (first && last) {
|
|
const qreal minPos = pos - first->position() - 0.0004999;
|
|
const qreal maxPos = pos + 1.0 - last->position() + 0.0004999;
|
|
|
|
if (max > maxPos)
|
|
max = maxPos;
|
|
if (min < minPos)
|
|
min = minPos;
|
|
|
|
if (first->position() == 0.0)
|
|
min = pos;
|
|
if (last->position() == 1.0)
|
|
max = pos;
|
|
}
|
|
|
|
const int spinMin = qRound(m_ui->positionSpinBox->minimum() * 1000);
|
|
const int spinMax = qRound(m_ui->positionSpinBox->maximum() * 1000);
|
|
|
|
const int newMin = qRound(min * 1000);
|
|
const int newMax = qRound(max * 1000);
|
|
|
|
m_ui->positionSpinBox->blockSignals(true);
|
|
if (spinMin != newMin || spinMax != newMax) {
|
|
m_ui->positionSpinBox->setRange((double)newMin / 1000, (double)newMax / 1000);
|
|
}
|
|
if (m_ui->positionSpinBox->value() != pos)
|
|
m_ui->positionSpinBox->setValue(pos);
|
|
m_ui->positionSpinBox->blockSignals(false);
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotChangeColor(const QColor &color)
|
|
{
|
|
QtGradientStop *stop = m_model->currentStop();
|
|
if (!stop)
|
|
return;
|
|
m_model->changeStop(stop, color);
|
|
QList<QtGradientStop *> stops = m_model->selectedStops();
|
|
QListIterator<QtGradientStop *> itStop(stops);
|
|
while (itStop.hasNext()) {
|
|
QtGradientStop *s = itStop.next();
|
|
if (s != stop)
|
|
m_model->changeStop(s, color);
|
|
}
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotChangeHue(const QColor &color)
|
|
{
|
|
QtGradientStop *stop = m_model->currentStop();
|
|
if (!stop)
|
|
return;
|
|
m_model->changeStop(stop, color);
|
|
QList<QtGradientStop *> stops = m_model->selectedStops();
|
|
QListIterator<QtGradientStop *> itStop(stops);
|
|
while (itStop.hasNext()) {
|
|
QtGradientStop *s = itStop.next();
|
|
if (s != stop) {
|
|
QColor c = s->color();
|
|
if (m_ui->hsvRadioButton->isChecked())
|
|
c.setHsvF(color.hueF(), c.saturationF(), c.valueF(), c.alphaF());
|
|
else
|
|
c.setRgbF(color.redF(), c.greenF(), c.blueF(), c.alphaF());
|
|
m_model->changeStop(s, c);
|
|
}
|
|
}
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotChangeHue(int color)
|
|
{
|
|
QColor c = m_ui->hueColorLine->color();
|
|
if (m_ui->hsvRadioButton->isChecked())
|
|
c.setHsvF((qreal)color / 360.0, c.saturationF(), c.valueF(), c.alphaF());
|
|
else
|
|
c.setRed(color);
|
|
slotChangeHue(c);
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotChangeSaturation(const QColor &color)
|
|
{
|
|
QtGradientStop *stop = m_model->currentStop();
|
|
if (!stop)
|
|
return;
|
|
m_model->changeStop(stop, color);
|
|
QList<QtGradientStop *> stops = m_model->selectedStops();
|
|
QListIterator<QtGradientStop *> itStop(stops);
|
|
while (itStop.hasNext()) {
|
|
QtGradientStop *s = itStop.next();
|
|
if (s != stop) {
|
|
QColor c = s->color();
|
|
if (m_ui->hsvRadioButton->isChecked()) {
|
|
c.setHsvF(c.hueF(), color.saturationF(), c.valueF(), c.alphaF());
|
|
int hue = c.hue();
|
|
if (hue == 360 || hue == -1)
|
|
c.setHsvF(0.0, c.saturationF(), c.valueF(), c.alphaF());
|
|
} else {
|
|
c.setRgbF(c.redF(), color.greenF(), c.blueF(), c.alphaF());
|
|
}
|
|
m_model->changeStop(s, c);
|
|
}
|
|
}
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotChangeSaturation(int color)
|
|
{
|
|
QColor c = m_ui->saturationColorLine->color();
|
|
if (m_ui->hsvRadioButton->isChecked())
|
|
c.setHsvF(c.hueF(), (qreal)color / 255, c.valueF(), c.alphaF());
|
|
else
|
|
c.setGreen(color);
|
|
slotChangeSaturation(c);
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotChangeValue(const QColor &color)
|
|
{
|
|
QtGradientStop *stop = m_model->currentStop();
|
|
if (!stop)
|
|
return;
|
|
m_model->changeStop(stop, color);
|
|
QList<QtGradientStop *> stops = m_model->selectedStops();
|
|
QListIterator<QtGradientStop *> itStop(stops);
|
|
while (itStop.hasNext()) {
|
|
QtGradientStop *s = itStop.next();
|
|
if (s != stop) {
|
|
QColor c = s->color();
|
|
if (m_ui->hsvRadioButton->isChecked()) {
|
|
c.setHsvF(c.hueF(), c.saturationF(), color.valueF(), c.alphaF());
|
|
int hue = c.hue();
|
|
if (hue == 360 || hue == -1)
|
|
c.setHsvF(0.0, c.saturationF(), c.valueF(), c.alphaF());
|
|
} else {
|
|
c.setRgbF(c.redF(), c.greenF(), color.blueF(), c.alphaF());
|
|
}
|
|
m_model->changeStop(s, c);
|
|
}
|
|
}
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotChangeValue(int color)
|
|
{
|
|
QColor c = m_ui->valueColorLine->color();
|
|
if (m_ui->hsvRadioButton->isChecked())
|
|
c.setHsvF(c.hueF(), c.saturationF(), (qreal)color / 255, c.alphaF());
|
|
else
|
|
c.setBlue(color);
|
|
slotChangeValue(c);
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotChangeAlpha(const QColor &color)
|
|
{
|
|
QtGradientStop *stop = m_model->currentStop();
|
|
if (!stop)
|
|
return;
|
|
m_model->changeStop(stop, color);
|
|
QList<QtGradientStop *> stops = m_model->selectedStops();
|
|
QListIterator<QtGradientStop *> itStop(stops);
|
|
while (itStop.hasNext()) {
|
|
QtGradientStop *s = itStop.next();
|
|
if (s != stop) {
|
|
QColor c = s->color();
|
|
if (m_ui->hsvRadioButton->isChecked()) {
|
|
c.setHsvF(c.hueF(), c.saturationF(), c.valueF(), color.alphaF());
|
|
int hue = c.hue();
|
|
if (hue == 360 || hue == -1)
|
|
c.setHsvF(0.0, c.saturationF(), c.valueF(), c.alphaF());
|
|
} else {
|
|
c.setRgbF(c.redF(), c.greenF(), c.blueF(), color.alphaF());
|
|
}
|
|
m_model->changeStop(s, c);
|
|
}
|
|
}
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotChangeAlpha(int color)
|
|
{
|
|
QColor c = m_ui->alphaColorLine->color();
|
|
if (m_ui->hsvRadioButton->isChecked())
|
|
c.setHsvF(c.hueF(), c.saturationF(), c.valueF(), (qreal)color / 255);
|
|
else
|
|
c.setAlpha(color);
|
|
slotChangeAlpha(c);
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotChangePosition(double value)
|
|
{
|
|
QtGradientStop *stop = m_model->currentStop();
|
|
if (!stop)
|
|
return;
|
|
|
|
m_model->moveStops(value);
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotChangeZoom(int value)
|
|
{
|
|
updateZoom(value / 100.0);
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotZoomIn()
|
|
{
|
|
double newZoom = m_ui->gradientStopsWidget->zoom() * 2;
|
|
if (newZoom > 100)
|
|
newZoom = 100;
|
|
updateZoom(newZoom);
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotZoomOut()
|
|
{
|
|
double newZoom = m_ui->gradientStopsWidget->zoom() / 2;
|
|
if (newZoom < 1)
|
|
newZoom = 1;
|
|
updateZoom(newZoom);
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotZoomAll()
|
|
{
|
|
updateZoom(1);
|
|
}
|
|
|
|
void QtGradientStopsControllerPrivate::slotZoomChanged(double zoom)
|
|
{
|
|
updateZoom(zoom);
|
|
}
|
|
|
|
QtGradientStopsController::QtGradientStopsController(QObject *parent)
|
|
: QObject(parent), d_ptr(new QtGradientStopsControllerPrivate())
|
|
{
|
|
d_ptr->q_ptr = this;
|
|
|
|
d_ptr->m_spec = QColor::Hsv;
|
|
}
|
|
|
|
void QtGradientStopsController::setUi(Ui::QtGradientEditor *ui)
|
|
{
|
|
d_ptr->m_ui = ui;
|
|
|
|
d_ptr->m_ui->hueColorLine->setColorComponent(QtColorLine::Hue);
|
|
d_ptr->m_ui->saturationColorLine->setColorComponent(QtColorLine::Saturation);
|
|
d_ptr->m_ui->valueColorLine->setColorComponent(QtColorLine::Value);
|
|
d_ptr->m_ui->alphaColorLine->setColorComponent(QtColorLine::Alpha);
|
|
|
|
d_ptr->m_model = new QtGradientStopsModel(this);
|
|
d_ptr->m_ui->gradientStopsWidget->setGradientStopsModel(d_ptr->m_model);
|
|
connect(d_ptr->m_model, SIGNAL(currentStopChanged(QtGradientStop*)),
|
|
this, SLOT(slotCurrentStopChanged(QtGradientStop*)));
|
|
connect(d_ptr->m_model, SIGNAL(stopMoved(QtGradientStop*,qreal)),
|
|
this, SLOT(slotStopMoved(QtGradientStop*,qreal)));
|
|
connect(d_ptr->m_model, SIGNAL(stopsSwapped(QtGradientStop*,QtGradientStop*)),
|
|
this, SLOT(slotStopsSwapped(QtGradientStop*,QtGradientStop*)));
|
|
connect(d_ptr->m_model, SIGNAL(stopChanged(QtGradientStop*,QColor)),
|
|
this, SLOT(slotStopChanged(QtGradientStop*,QColor)));
|
|
connect(d_ptr->m_model, SIGNAL(stopSelected(QtGradientStop*,bool)),
|
|
this, SLOT(slotStopSelected(QtGradientStop*,bool)));
|
|
connect(d_ptr->m_model, SIGNAL(stopAdded(QtGradientStop*)),
|
|
this, SLOT(slotStopAdded(QtGradientStop*)));
|
|
connect(d_ptr->m_model, SIGNAL(stopRemoved(QtGradientStop*)),
|
|
this, SLOT(slotStopRemoved(QtGradientStop*)));
|
|
|
|
connect(d_ptr->m_ui->hueColorLine, SIGNAL(colorChanged(QColor)),
|
|
this, SLOT(slotChangeHue(QColor)));
|
|
connect(d_ptr->m_ui->saturationColorLine, SIGNAL(colorChanged(QColor)),
|
|
this, SLOT(slotChangeSaturation(QColor)));
|
|
connect(d_ptr->m_ui->valueColorLine, SIGNAL(colorChanged(QColor)),
|
|
this, SLOT(slotChangeValue(QColor)));
|
|
connect(d_ptr->m_ui->alphaColorLine, SIGNAL(colorChanged(QColor)),
|
|
this, SLOT(slotChangeAlpha(QColor)));
|
|
connect(d_ptr->m_ui->colorButton, SIGNAL(colorChanged(QColor)),
|
|
this, SLOT(slotChangeColor(QColor)));
|
|
|
|
connect(d_ptr->m_ui->hueSpinBox, SIGNAL(valueChanged(int)),
|
|
this, SLOT(slotChangeHue(int)));
|
|
connect(d_ptr->m_ui->saturationSpinBox, SIGNAL(valueChanged(int)),
|
|
this, SLOT(slotChangeSaturation(int)));
|
|
connect(d_ptr->m_ui->valueSpinBox, SIGNAL(valueChanged(int)),
|
|
this, SLOT(slotChangeValue(int)));
|
|
connect(d_ptr->m_ui->alphaSpinBox, SIGNAL(valueChanged(int)),
|
|
this, SLOT(slotChangeAlpha(int)));
|
|
|
|
connect(d_ptr->m_ui->positionSpinBox, SIGNAL(valueChanged(double)),
|
|
this, SLOT(slotChangePosition(double)));
|
|
|
|
connect(d_ptr->m_ui->zoomSpinBox, SIGNAL(valueChanged(int)),
|
|
this, SLOT(slotChangeZoom(int)));
|
|
connect(d_ptr->m_ui->zoomInButton, SIGNAL(clicked()),
|
|
this, SLOT(slotZoomIn()));
|
|
connect(d_ptr->m_ui->zoomOutButton, SIGNAL(clicked()),
|
|
this, SLOT(slotZoomOut()));
|
|
connect(d_ptr->m_ui->zoomAllButton, SIGNAL(clicked()),
|
|
this, SLOT(slotZoomAll()));
|
|
connect(d_ptr->m_ui->gradientStopsWidget, SIGNAL(zoomChanged(double)),
|
|
this, SLOT(slotZoomChanged(double)));
|
|
|
|
connect(d_ptr->m_ui->hsvRadioButton, SIGNAL(clicked()),
|
|
this, SLOT(slotHsvClicked()));
|
|
connect(d_ptr->m_ui->rgbRadioButton, SIGNAL(clicked()),
|
|
this, SLOT(slotRgbClicked()));
|
|
|
|
d_ptr->enableCurrent(false);
|
|
d_ptr->m_ui->zoomInButton->setIcon(QIcon(QLatin1String(":/trolltech/qtgradienteditor/images/zoomin.png")));
|
|
d_ptr->m_ui->zoomOutButton->setIcon(QIcon(QLatin1String(":/trolltech/qtgradienteditor/images/zoomout.png")));
|
|
d_ptr->updateZoom(1);
|
|
}
|
|
|
|
QtGradientStopsController::~QtGradientStopsController()
|
|
{
|
|
}
|
|
|
|
void QtGradientStopsController::setGradientStops(const QGradientStops &stops)
|
|
{
|
|
d_ptr->m_model->clear();
|
|
QVectorIterator<QPair<qreal, QColor> > it(stops);
|
|
QtGradientStop *first = 0;
|
|
while (it.hasNext()) {
|
|
QPair<qreal, QColor> pair = it.next();
|
|
QtGradientStop *stop = d_ptr->m_model->addStop(pair.first, pair.second);
|
|
if (!first)
|
|
first = stop;
|
|
}
|
|
if (first)
|
|
d_ptr->m_model->setCurrentStop(first);
|
|
}
|
|
|
|
QGradientStops QtGradientStopsController::gradientStops() const
|
|
{
|
|
QGradientStops stops;
|
|
QList<QtGradientStop *> stopsList = d_ptr->m_model->stops().values();
|
|
QListIterator<QtGradientStop *> itStop(stopsList);
|
|
while (itStop.hasNext()) {
|
|
QtGradientStop *stop = itStop.next();
|
|
stops << QPair<qreal, QColor>(stop->position(), stop->color());
|
|
}
|
|
return stops;
|
|
}
|
|
|
|
QColor::Spec QtGradientStopsController::spec() const
|
|
{
|
|
return d_ptr->m_spec;
|
|
}
|
|
|
|
void QtGradientStopsController::setSpec(QColor::Spec spec)
|
|
{
|
|
if (d_ptr->m_spec == spec)
|
|
return;
|
|
|
|
d_ptr->m_spec = spec;
|
|
if (d_ptr->m_spec == QColor::Rgb) {
|
|
d_ptr->m_ui->rgbRadioButton->setChecked(true);
|
|
d_ptr->slotRgbClicked();
|
|
} else {
|
|
d_ptr->m_ui->hsvRadioButton->setChecked(true);
|
|
d_ptr->slotHsvClicked();
|
|
}
|
|
}
|
|
|
|
QT_END_NAMESPACE
|
|
|
|
#include "moc_qtgradientstopscontroller.cpp"
|