Revision control
++ // Copyright (C) 2016 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++ // Qt-Security score:significant reason:default
++
++ #include "qtgradienteditor_p.h"
++ #include "qtgradientstopscontroller_p.h"
++ #include "ui_qtgradienteditor.h"
++
++ #include <QtWidgets/qbuttongroup.h>
++
++ QT_BEGIN_NAMESPACE
++
++ using namespace Qt::StringLiterals;
++
++ class QtGradientEditorPrivate : public QObject
++ {
++ Q_OBJECT
++ QtGradientEditor *q_ptr;
++ Q_DECLARE_PUBLIC(QtGradientEditor)
++ public:
++ QtGradientEditorPrivate(QtGradientEditor *q);
++
++ void setBackgroundCheckered(bool checkered);
++
++ void slotGradientStopsChanged(const QGradientStops &stops);
++ void slotTypeChanged(int type);
++ void slotSpreadChanged(int spread);
++ void slotStartLinearXChanged(double value);
++ void slotStartLinearYChanged(double value);
++ void slotEndLinearXChanged(double value);
++ void slotEndLinearYChanged(double value);
++ void slotCentralRadialXChanged(double value);
++ void slotCentralRadialYChanged(double value);
++ void slotFocalRadialXChanged(double value);
++ void slotFocalRadialYChanged(double value);
++ void slotRadiusRadialChanged(double value);
++ void slotCentralConicalXChanged(double value);
++ void slotCentralConicalYChanged(double value);
++ void slotAngleConicalChanged(double value);
++
++ void slotDetailsChanged(bool details);
++
++ void startLinearChanged(QPointF point);
++ void endLinearChanged(QPointF point);
++ void centralRadialChanged(QPointF point);
++ void focalRadialChanged(QPointF point);
++ void radiusRadialChanged(qreal radius);
++ void centralConicalChanged(const QPointF &point);
++ void angleConicalChanged(qreal angle);
++
++ void setStartLinear(QPointF point);
++ void setEndLinear(QPointF point);
++ void setCentralRadial(QPointF point);
++ void setFocalRadial(QPointF point);
++ void setRadiusRadial(qreal radius);
++ void setCentralConical(QPointF point);
++ void setAngleConical(qreal angle);
++
++ void setType(QGradient::Type type);
++ void showDetails(bool details);
++
++ using DoubleSlotPtr = void (QtGradientEditorPrivate::*)(double);
++ void setupSpinBox(QDoubleSpinBox *spinBox, DoubleSlotPtr slot, double max = 1.0, double step = 0.01, int decimals = 3);
++ void reset();
++ void setLayout(bool details);
++ void layoutDetails(bool details);
++ bool row4Visible() const;
++ bool row5Visible() const;
++ int extensionWidthHint() const;
++
++ void setCombos(bool combos);
++
++ QGradient gradient() const;
++ void updateGradient(bool emitSignal);
++
++ Ui::QtGradientEditor m_ui;
++ QtGradientStopsController *m_gradientStopsController;
++
++ QDoubleSpinBox *startLinearXSpinBox = nullptr;
++ QDoubleSpinBox *startLinearYSpinBox = nullptr;
++ QDoubleSpinBox *endLinearXSpinBox = nullptr;
++ QDoubleSpinBox *endLinearYSpinBox = nullptr;
++ QDoubleSpinBox *centralRadialXSpinBox = nullptr;
++ QDoubleSpinBox *centralRadialYSpinBox = nullptr;
++ QDoubleSpinBox *focalRadialXSpinBox = nullptr;
++ QDoubleSpinBox *focalRadialYSpinBox = nullptr;
++ QDoubleSpinBox *radiusRadialSpinBox = nullptr;
++ QDoubleSpinBox *centralConicalXSpinBox = nullptr;
++ QDoubleSpinBox *centralConicalYSpinBox = nullptr;
++ QDoubleSpinBox *angleConicalSpinBox = nullptr;
++
++ QButtonGroup *m_typeGroup = nullptr;
++ QButtonGroup *m_spreadGroup = nullptr;
++
++ QGradient::Type m_type = QGradient::RadialGradient;
++
++ QGridLayout *m_gridLayout = nullptr;
++ QWidget *m_hiddenWidget = nullptr;
++ QGridLayout *m_hiddenLayout = nullptr;
++ bool m_details = false;
++ bool m_detailsButtonVisible = true;
++ bool m_backgroundCheckered = true;
++
++ QGradient m_gradient;
++
++ bool m_combos = true;
++ };
++
++ QtGradientEditorPrivate::QtGradientEditorPrivate(QtGradientEditor *q)
++ : q_ptr(q)
++ , m_gradientStopsController(new QtGradientStopsController(this))
++ , m_gradient(QLinearGradient())
++ {
++ m_ui.setupUi(q_ptr);
++ m_gradientStopsController->setUi(&m_ui);
++ reset();
++ setType(QGradient::LinearGradient);
++ setCombos(!m_combos);
++
++ showDetails(m_details);
++ setBackgroundCheckered(m_backgroundCheckered);
++
++ setStartLinear(QPointF(0, 0));
++ setEndLinear(QPointF(1, 1));
++ setCentralRadial(QPointF(0.5, 0.5));
++ setFocalRadial(QPointF(0.5, 0.5));
++ setRadiusRadial(0.5);
++ setCentralConical(QPointF(0.5, 0.5));
++ setAngleConical(0);
++
++ QIcon icon;
++ icon.addPixmap(q_ptr->style()->standardPixmap(QStyle::SP_ArrowRight), QIcon::Normal, QIcon::Off);
++ icon.addPixmap(q_ptr->style()->standardPixmap(QStyle::SP_ArrowLeft), QIcon::Normal, QIcon::On);
++ m_ui.detailsButton->setIcon(icon);
++
++ connect(m_ui.detailsButton, &QAbstractButton::clicked,
++ this, &QtGradientEditorPrivate::slotDetailsChanged);
++ connect(m_gradientStopsController, &QtGradientStopsController::gradientStopsChanged,
++ this, &QtGradientEditorPrivate::slotGradientStopsChanged);
++
++ QIcon iconLinear(":/qt-project.org/qtgradienteditor/images/typelinear.png"_L1);
++ QIcon iconRadial(":/qt-project.org/qtgradienteditor/images/typeradial.png"_L1);
++ QIcon iconConical(":/qt-project.org/qtgradienteditor/images/typeconical.png"_L1);
++
++ m_ui.typeComboBox->addItem(iconLinear, QtGradientEditor::tr("Linear"));
++ m_ui.typeComboBox->addItem(iconRadial, QtGradientEditor::tr("Radial"));
++ m_ui.typeComboBox->addItem(iconConical, QtGradientEditor::tr("Conical"));
++
++ m_ui.linearButton->setIcon(iconLinear);
++ m_ui.radialButton->setIcon(iconRadial);
++ m_ui.conicalButton->setIcon(iconConical);
++
++ m_typeGroup = new QButtonGroup(this);
++ m_typeGroup->addButton(m_ui.linearButton, 0);
++ m_typeGroup->addButton(m_ui.radialButton, 1);
++ m_typeGroup->addButton(m_ui.conicalButton, 2);
++
++ connect(m_typeGroup, &QButtonGroup::idClicked,
++ this, &QtGradientEditorPrivate::slotTypeChanged);
++ connect(m_ui.typeComboBox, &QComboBox::activated,
++ this, &QtGradientEditorPrivate::slotTypeChanged);
++
++ QIcon iconPad(":/qt-project.org/qtgradienteditor/images/spreadpad.png"_L1);
++ QIcon iconRepeat(":/qt-project.org/qtgradienteditor/images/spreadrepeat.png"_L1);
++ QIcon iconReflect(":/qt-project.org/qtgradienteditor/images/spreadreflect.png"_L1);
++
++ m_ui.spreadComboBox->addItem(iconPad, QtGradientEditor::tr("Pad"));
++ m_ui.spreadComboBox->addItem(iconRepeat, QtGradientEditor::tr("Repeat"));
++ m_ui.spreadComboBox->addItem(iconReflect, QtGradientEditor::tr("Reflect"));
++
++ m_ui.padButton->setIcon(iconPad);
++ m_ui.repeatButton->setIcon(iconRepeat);
++ m_ui.reflectButton->setIcon(iconReflect);
++
++ m_spreadGroup = new QButtonGroup(this);
++ m_spreadGroup->addButton(m_ui.padButton, 0);
++ m_spreadGroup->addButton(m_ui.repeatButton, 1);
++ m_spreadGroup->addButton(m_ui.reflectButton, 2);
++ connect(m_spreadGroup, &QButtonGroup::idClicked,
++ this, &QtGradientEditorPrivate::slotSpreadChanged);
++ connect(m_ui.spreadComboBox, &QComboBox::activated,
++ this, &QtGradientEditorPrivate::slotSpreadChanged);
++
++ connect(m_ui.gradientWidget, &QtGradientWidget::startLinearChanged,
++ this, &QtGradientEditorPrivate::startLinearChanged);
++ connect(m_ui.gradientWidget, &QtGradientWidget::endLinearChanged,
++ this, &QtGradientEditorPrivate::endLinearChanged);
++ connect(m_ui.gradientWidget, &QtGradientWidget::centralRadialChanged,
++ this, &QtGradientEditorPrivate::centralRadialChanged);
++ connect(m_ui.gradientWidget, &QtGradientWidget::focalRadialChanged,
++ this, &QtGradientEditorPrivate::focalRadialChanged);
++ connect(m_ui.gradientWidget, &QtGradientWidget::radiusRadialChanged,
++ this, &QtGradientEditorPrivate::radiusRadialChanged);
++ connect(m_ui.gradientWidget, &QtGradientWidget::centralConicalChanged,
++ this, &QtGradientEditorPrivate::centralConicalChanged);
++ connect(m_ui.gradientWidget, &QtGradientWidget::angleConicalChanged,
++ this, &QtGradientEditorPrivate::angleConicalChanged);
++
++ QGradientStops stops = gradient().stops();
++ m_gradientStopsController->setGradientStops(stops);
++ m_ui.gradientWidget->setGradientStops(stops);
++ }
++
++ QGradient QtGradientEditorPrivate::gradient() const
++ {
++ QGradient *gradient = nullptr;
++ switch (m_ui.gradientWidget->gradientType()) {
++ case QGradient::LinearGradient:
++ gradient = new QLinearGradient(m_ui.gradientWidget->startLinear(),
++ m_ui.gradientWidget->endLinear());
++ break;
++ case QGradient::RadialGradient:
++ gradient = new QRadialGradient(m_ui.gradientWidget->centralRadial(),
++ m_ui.gradientWidget->radiusRadial(),
++ m_ui.gradientWidget->focalRadial());
++ break;
++ case QGradient::ConicalGradient:
++ gradient = new QConicalGradient(m_ui.gradientWidget->centralConical(),
++ m_ui.gradientWidget->angleConical());
++ break;
++ default:
++ break;
++ }
++ if (!gradient)
++ return QGradient();
++ gradient->setStops(m_ui.gradientWidget->gradientStops());
++ gradient->setSpread(m_ui.gradientWidget->gradientSpread());
++ gradient->setCoordinateMode(QGradient::StretchToDeviceMode);
++ QGradient gr = *gradient;
++ delete gradient;
++ return gr;
++ }
++
++ void QtGradientEditorPrivate::updateGradient(bool emitSignal)
++ {
++ QGradient grad = gradient();
++ if (m_gradient == grad)
++ return;
++
++ m_gradient = grad;
++ if (emitSignal)
++ emit q_ptr->gradientChanged(m_gradient);
++ }
++
++ void QtGradientEditorPrivate::setCombos(bool combos)
++ {
++ if (m_combos == combos)
++ return;
++
++ m_combos = combos;
++ m_ui.linearButton->setVisible(!m_combos);
++ m_ui.radialButton->setVisible(!m_combos);
++ m_ui.conicalButton->setVisible(!m_combos);
++ m_ui.padButton->setVisible(!m_combos);
++ m_ui.repeatButton->setVisible(!m_combos);
++ m_ui.reflectButton->setVisible(!m_combos);
++ m_ui.typeComboBox->setVisible(m_combos);
++ m_ui.spreadComboBox->setVisible(m_combos);
++ }
++
++ void QtGradientEditorPrivate::setLayout(bool details)
++ {
++ QHBoxLayout *hboxLayout = new QHBoxLayout();
++ hboxLayout->setObjectName(QString::fromUtf8("hboxLayout"));
++ hboxLayout->addWidget(m_ui.typeComboBox);
++ hboxLayout->addWidget(m_ui.spreadComboBox);
++ QHBoxLayout *typeLayout = new QHBoxLayout();
++ typeLayout->setSpacing(0);
++ typeLayout->addWidget(m_ui.linearButton);
++ typeLayout->addWidget(m_ui.radialButton);
++ typeLayout->addWidget(m_ui.conicalButton);
++ hboxLayout->addLayout(typeLayout);
++ QHBoxLayout *spreadLayout = new QHBoxLayout();
++ spreadLayout->setSpacing(0);
++ spreadLayout->addWidget(m_ui.padButton);
++ spreadLayout->addWidget(m_ui.repeatButton);
++ spreadLayout->addWidget(m_ui.reflectButton);
++ hboxLayout->addLayout(spreadLayout);
++ hboxLayout->addItem(new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Minimum));
++ hboxLayout->addWidget(m_ui.detailsButton);
++ m_gridLayout->addLayout(hboxLayout, 0, 0, 1, 2);
++ int span = 1;
++ if (details)
++ span = 7;
++ m_gridLayout->addWidget(m_ui.frame, 1, 0, span, 2);
++ int row = 2;
++ if (details) {
++ row = 8;
++ span = 4;
++ }
++ m_gridLayout->addWidget(m_ui.gradientStopsWidget, row, 0, span, 2);
++ QHBoxLayout *hboxLayout1 = new QHBoxLayout();
++ hboxLayout1->setObjectName(QString::fromUtf8("hboxLayout1"));
++ hboxLayout1->addWidget(m_ui.colorLabel);
++ hboxLayout1->addWidget(m_ui.colorButton);
++ hboxLayout1->addWidget(m_ui.hsvRadioButton);
++ hboxLayout1->addWidget(m_ui.rgbRadioButton);
++ hboxLayout1->addItem(new QSpacerItem(16, 23, QSizePolicy::Expanding, QSizePolicy::Minimum));
++ int addRow = 0;
++ if (details)
++ addRow = 9;
++ m_gridLayout->addLayout(hboxLayout1, 3 + addRow, 0, 1, 2);
++ m_gridLayout->addWidget(m_ui.hLabel, 4 + addRow, 0, 1, 1);
++ m_gridLayout->addWidget(m_ui.frame_2, 4 + addRow, 1, 1, 1);
++ m_gridLayout->addWidget(m_ui.sLabel, 5 + addRow, 0, 1, 1);
++ m_gridLayout->addWidget(m_ui.frame_5, 5 + addRow, 1, 1, 1);
++ m_gridLayout->addWidget(m_ui.vLabel, 6 + addRow, 0, 1, 1);
++ m_gridLayout->addWidget(m_ui.frame_3, 6 + addRow, 1, 1, 1);
++ m_gridLayout->addWidget(m_ui.aLabel, 7 + addRow, 0, 1, 1);
++ m_gridLayout->addWidget(m_ui.frame_4, 7 + addRow, 1, 1, 1);
++
++ if (details) {
++ layoutDetails(details);
++ }
++ }
++
++ void QtGradientEditorPrivate::layoutDetails(bool details)
++ {
++ QGridLayout *gridLayout = m_gridLayout;
++ int col = 2;
++ if (!details) {
++ col = 0;
++ if (!m_hiddenWidget) {
++ m_hiddenWidget = new QWidget();
++ m_hiddenLayout = new QGridLayout(m_hiddenWidget);
++ m_hiddenLayout->setContentsMargins(0, 0, 0, 0);
++ m_hiddenLayout->setSizeConstraint(QLayout::SetFixedSize);
++ }
++ gridLayout = m_hiddenLayout;
++ }
++ gridLayout->addWidget(m_ui.label1, 1, col + 0, 1, 1);
++ gridLayout->addWidget(m_ui.spinBox1, 1, col + 1, 1, 1);
++ gridLayout->addWidget(m_ui.label2, 2, col + 0, 1, 1);
++ gridLayout->addWidget(m_ui.spinBox2, 2, col + 1, 1, 1);
++ gridLayout->addWidget(m_ui.label3, 3, col + 0, 1, 1);
++ gridLayout->addWidget(m_ui.spinBox3, 3, col + 1, 1, 1);
++ gridLayout->addWidget(m_ui.label4, 4, col + 0, 1, 1);
++ gridLayout->addWidget(m_ui.spinBox4, 4, col + 1, 1, 1);
++ gridLayout->addWidget(m_ui.label5, 5, col + 0, 1, 1);
++ gridLayout->addWidget(m_ui.spinBox5, 5, col + 1, 1, 1);
++ gridLayout->addItem(new QSpacerItem(0, 0, QSizePolicy::Minimum, QSizePolicy::Expanding), 6, col + 0, 1, 1);
++ gridLayout->addWidget(m_ui.line1Widget, 7, col + 0, 1, 2);
++ gridLayout->addWidget(m_ui.zoomLabel, 8, col + 0, 1, 1);
++ gridLayout->addWidget(m_ui.zoomWidget, 8, col + 1, 1, 1);
++ gridLayout->addWidget(m_ui.zoomButtonsWidget, 9, col + 0, 1, 1);
++ gridLayout->addWidget(m_ui.zoomAllButton, 9, col + 1, 1, 1);
++ gridLayout->addItem(new QSpacerItem(0, 0, QSizePolicy::Minimum, QSizePolicy::Preferred), 10, col + 0, 1, 1);
++ gridLayout->addWidget(m_ui.line2Widget, 11, col + 0, 1, 2);
++ gridLayout->addWidget(m_ui.positionLabel, 12, col + 0, 1, 1);
++ gridLayout->addWidget(m_ui.positionWidget, 12, col + 1, 1, 1);
++ gridLayout->addWidget(m_ui.hueLabel, 13, col + 0, 1, 1);
++ gridLayout->addWidget(m_ui.hueWidget, 13, col + 1, 1, 1);
++ gridLayout->addWidget(m_ui.saturationLabel, 14, col + 0, 1, 1);
++ gridLayout->addWidget(m_ui.saturationWidget, 14, col + 1, 1, 1);
++ gridLayout->addWidget(m_ui.valueLabel, 15, col + 0, 1, 1);
++ gridLayout->addWidget(m_ui.valueWidget, 15, col + 1, 1, 1);
++ gridLayout->addWidget(m_ui.alphaLabel, 16, col + 0, 1, 1);
++ gridLayout->addWidget(m_ui.alphaWidget, 16, col + 1, 1, 1);
++
++ if (details) {
++ if (m_hiddenLayout) {
++ delete m_hiddenLayout;
++ m_hiddenLayout = 0;
++ }
++ if (m_hiddenWidget) {
++ delete m_hiddenWidget;
++ m_hiddenWidget = 0;
++ }
++ }
++ }
++
++ int QtGradientEditorPrivate::extensionWidthHint() const
++ {
++ if (m_details)
++ return q_ptr->size().width() - m_ui.gradientStopsWidget->size().width();
++
++ const int space = m_ui.spinBox1->geometry().left() - m_ui.label1->geometry().right();
++
++ return m_hiddenLayout->minimumSize().width() + space;
++ }
++
++ void QtGradientEditorPrivate::slotDetailsChanged(bool details)
++ {
++ if (m_details == details)
++ return;
++
++ showDetails(details);
++ }
++
++ bool QtGradientEditorPrivate::row4Visible() const
++ {
++ if (m_type == QGradient::ConicalGradient)
++ return false;
++ return true;
++ }
++
++ bool QtGradientEditorPrivate::row5Visible() const
++ {
++ if (m_type == QGradient::RadialGradient)
++ return true;
++ return false;
++ }
++
++ void QtGradientEditorPrivate::showDetails(bool details)
++ {
++ bool blocked = m_ui.detailsButton->signalsBlocked();
++ m_ui.detailsButton->blockSignals(true);
++ m_ui.detailsButton->setChecked(details);
++ m_ui.detailsButton->blockSignals(blocked);
++
++ bool updates = q_ptr->updatesEnabled();
++ q_ptr->setUpdatesEnabled(false);
++
++ if (m_gridLayout) {
++ m_gridLayout->setEnabled(false);
++ delete m_gridLayout;
++ m_gridLayout = 0;
++ }
++
++ if (!details) {
++ layoutDetails(details);
++ }
++
++ emit q_ptr->aboutToShowDetails(details, extensionWidthHint());
++ m_details = details;
++
++ m_gridLayout = new QGridLayout(q_ptr);
++ m_gridLayout->setEnabled(false);
++ m_gridLayout->setObjectName(QString::fromUtf8("gridLayout"));
++ m_gridLayout->setContentsMargins(0, 0, 0, 0);
++
++ m_ui.label4->setVisible(row4Visible());
++ m_ui.label5->setVisible(row5Visible());
++ m_ui.spinBox4->setVisible(row4Visible());
++ m_ui.spinBox5->setVisible(row5Visible());
++
++ setLayout(details);
++ m_gridLayout->setEnabled(true);
++
++ q_ptr->setUpdatesEnabled(updates);
++ q_ptr->update();
++ }
++
++ void QtGradientEditorPrivate::setupSpinBox(QDoubleSpinBox *spinBox, DoubleSlotPtr slot,
++ double max, double step, int decimals)
++ {
++ bool blocked = spinBox->signalsBlocked();
++ spinBox->blockSignals(true);
++ spinBox->setDecimals(decimals);
++ spinBox->setMaximum(max);
++ spinBox->setSingleStep(step);
++ spinBox->blockSignals(blocked);
++ QObject::connect(spinBox, &QDoubleSpinBox::valueChanged, this, slot);
++ }
++
++ void QtGradientEditorPrivate::reset()
++ {
++ startLinearXSpinBox = 0;
++ startLinearYSpinBox = 0;
++ endLinearXSpinBox = 0;
++ endLinearYSpinBox = 0;
++ centralRadialXSpinBox = 0;
++ centralRadialYSpinBox = 0;
++ focalRadialXSpinBox = 0;
++ focalRadialYSpinBox = 0;
++ radiusRadialSpinBox = 0;
++ centralConicalXSpinBox = 0;
++ centralConicalYSpinBox = 0;
++ angleConicalSpinBox = 0;
++ }
++
++ void QtGradientEditorPrivate::setType(QGradient::Type type)
++ {
++ if (m_type == type)
++ return;
++
++ m_type = type;
++ m_ui.spinBox1->disconnect(this);
++ m_ui.spinBox2->disconnect(this);
++ m_ui.spinBox3->disconnect(this);
++ m_ui.spinBox4->disconnect(this);
++ m_ui.spinBox5->disconnect(this);
++
++ reset();
++
++ bool ena = true;
++
++ if (m_gridLayout) {
++ ena = m_gridLayout->isEnabled();
++ m_gridLayout->setEnabled(false);
++ }
++
++ bool spreadEnabled = true;
++
++ if (type == QGradient::LinearGradient) {
++ startLinearXSpinBox = m_ui.spinBox1;
++ setupSpinBox(startLinearXSpinBox, &QtGradientEditorPrivate::slotStartLinearXChanged);
++ m_ui.label1->setText(QCoreApplication::translate("QtGradientEditor", "Start X"));
++
++ startLinearYSpinBox = m_ui.spinBox2;
++ setupSpinBox(startLinearYSpinBox, &QtGradientEditorPrivate::slotStartLinearYChanged);
++ m_ui.label2->setText(QCoreApplication::translate("QtGradientEditor", "Start Y"));
++
++ endLinearXSpinBox = m_ui.spinBox3;
++ setupSpinBox(endLinearXSpinBox, &QtGradientEditorPrivate::slotEndLinearXChanged);
++ m_ui.label3->setText(QCoreApplication::translate("QtGradientEditor", "Final X"));
++
++ endLinearYSpinBox = m_ui.spinBox4;
++ setupSpinBox(endLinearYSpinBox, &QtGradientEditorPrivate::slotEndLinearYChanged);
++ m_ui.label4->setText(QCoreApplication::translate("QtGradientEditor", "Final Y"));
++
++ setStartLinear(m_ui.gradientWidget->startLinear());
++ setEndLinear(m_ui.gradientWidget->endLinear());
++ } else if (type == QGradient::RadialGradient) {
++ centralRadialXSpinBox = m_ui.spinBox1;
++ setupSpinBox(centralRadialXSpinBox, &QtGradientEditorPrivate::slotCentralRadialXChanged);
++ m_ui.label1->setText(QCoreApplication::translate("QtGradientEditor", "Central X"));
++
++ centralRadialYSpinBox = m_ui.spinBox2;
++ setupSpinBox(centralRadialYSpinBox, &QtGradientEditorPrivate::slotCentralRadialYChanged);
++ m_ui.label2->setText(QCoreApplication::translate("QtGradientEditor", "Central Y"));
++
++ focalRadialXSpinBox = m_ui.spinBox3;
++ setupSpinBox(focalRadialXSpinBox, &QtGradientEditorPrivate::slotFocalRadialXChanged);
++ m_ui.label3->setText(QCoreApplication::translate("QtGradientEditor", "Focal X"));
++
++ focalRadialYSpinBox = m_ui.spinBox4;
++ setupSpinBox(focalRadialYSpinBox, &QtGradientEditorPrivate::slotFocalRadialYChanged);
++ m_ui.label4->setText(QCoreApplication::translate("QtGradientEditor", "Focal Y"));
++
++ radiusRadialSpinBox = m_ui.spinBox5;
++ setupSpinBox(radiusRadialSpinBox, &QtGradientEditorPrivate::slotRadiusRadialChanged, 2.0);
++ m_ui.label5->setText(QCoreApplication::translate("QtGradientEditor", "Radius"));
++
++ setCentralRadial(m_ui.gradientWidget->centralRadial());
++ setFocalRadial(m_ui.gradientWidget->focalRadial());
++ setRadiusRadial(m_ui.gradientWidget->radiusRadial());
++ } else if (type == QGradient::ConicalGradient) {
++ centralConicalXSpinBox = m_ui.spinBox1;
++ setupSpinBox(centralConicalXSpinBox, &QtGradientEditorPrivate::slotCentralConicalXChanged);
++ m_ui.label1->setText(QCoreApplication::translate("QtGradientEditor", "Central X"));
++
++ centralConicalYSpinBox = m_ui.spinBox2;
++ setupSpinBox(centralConicalYSpinBox, &QtGradientEditorPrivate::slotCentralConicalYChanged);
++ m_ui.label2->setText(QCoreApplication::translate("QtGradientEditor", "Central Y"));
++
++ angleConicalSpinBox = m_ui.spinBox3;
++ setupSpinBox(angleConicalSpinBox, &QtGradientEditorPrivate::slotAngleConicalChanged, 360.0, 1.0, 1);
++ m_ui.label3->setText(QCoreApplication::translate("QtGradientEditor", "Angle"));
++
++ setCentralConical(m_ui.gradientWidget->centralConical());
++ setAngleConical(m_ui.gradientWidget->angleConical());
++
++ spreadEnabled = false;
++ }
++ m_ui.spreadComboBox->setEnabled(spreadEnabled);
++ m_ui.padButton->setEnabled(spreadEnabled);
++ m_ui.repeatButton->setEnabled(spreadEnabled);
++ m_ui.reflectButton->setEnabled(spreadEnabled);
++
++ m_ui.label4->setVisible(row4Visible());
++ m_ui.spinBox4->setVisible(row4Visible());
++ m_ui.label5->setVisible(row5Visible());
++ m_ui.spinBox5->setVisible(row5Visible());
++
++ if (m_gridLayout)
++ m_gridLayout->setEnabled(ena);
++ }
++
++ void QtGradientEditorPrivate::setBackgroundCheckered(bool checkered)
++ {
++ m_backgroundCheckered = checkered;
++ m_ui.hueColorLine->setBackgroundCheckered(checkered);
++ m_ui.saturationColorLine->setBackgroundCheckered(checkered);
++ m_ui.valueColorLine->setBackgroundCheckered(checkered);
++ m_ui.alphaColorLine->setBackgroundCheckered(checkered);
++ m_ui.gradientWidget->setBackgroundCheckered(checkered);
++ m_ui.gradientStopsWidget->setBackgroundCheckered(checkered);
++ m_ui.colorButton->setBackgroundCheckered(checkered);
++ }
++
++ void QtGradientEditorPrivate::slotGradientStopsChanged(const QGradientStops &stops)
++ {
++ m_ui.gradientWidget->setGradientStops(stops);
++ updateGradient(true);
++ }
++
++ void QtGradientEditorPrivate::slotTypeChanged(int idx)
++ {
++ QGradient::Type type = QGradient::NoGradient;
++ if (idx == 0)
++ type = QGradient::LinearGradient;
++ else if (idx == 1)
++ type = QGradient::RadialGradient;
++ else if (idx == 2)
++ type = QGradient::ConicalGradient;
++ setType(type);
++ m_ui.typeComboBox->setCurrentIndex(idx);
++ m_typeGroup->button(idx)->setChecked(true);
++ m_ui.gradientWidget->setGradientType(type);
++ updateGradient(true);
++ }
++
++ void QtGradientEditorPrivate::slotSpreadChanged(int spread)
++ {
++ if (spread == 0) {
++ m_ui.gradientWidget->setGradientSpread(QGradient::PadSpread);
++ } else if (spread == 1) {
++ m_ui.gradientWidget->setGradientSpread(QGradient::RepeatSpread);
++ } else if (spread == 2) {
++ m_ui.gradientWidget->setGradientSpread(QGradient::ReflectSpread);
++ }
++ m_ui.spreadComboBox->setCurrentIndex(spread);
++ updateGradient(true);
++ }
++
++ void QtGradientEditorPrivate::slotStartLinearXChanged(double value)
++ {
++ QPointF point = m_ui.gradientWidget->startLinear();
++ point.setX(value);
++ m_ui.gradientWidget->setStartLinear(point);
++ updateGradient(true);
++ }
++
++ void QtGradientEditorPrivate::slotStartLinearYChanged(double value)
++ {
++ QPointF point = m_ui.gradientWidget->startLinear();
++ point.setY(value);
++ m_ui.gradientWidget->setStartLinear(point);
++ updateGradient(true);
++ }
++
++ void QtGradientEditorPrivate::slotEndLinearXChanged(double value)
++ {
++ QPointF point = m_ui.gradientWidget->endLinear();
++ point.setX(value);
++ m_ui.gradientWidget->setEndLinear(point);
++ updateGradient(true);
++ }
++
++ void QtGradientEditorPrivate::slotEndLinearYChanged(double value)
++ {
++ QPointF point = m_ui.gradientWidget->endLinear();
++ point.setY(value);
++ m_ui.gradientWidget->setEndLinear(point);
++ updateGradient(true);
++ }
++
++ void QtGradientEditorPrivate::slotCentralRadialXChanged(double value)
++ {
++ QPointF point = m_ui.gradientWidget->centralRadial();
++ point.setX(value);
++ m_ui.gradientWidget->setCentralRadial(point);
++ updateGradient(true);
++ }
++
++ void QtGradientEditorPrivate::slotCentralRadialYChanged(double value)
++ {
++ QPointF point = m_ui.gradientWidget->centralRadial();
++ point.setY(value);
++ m_ui.gradientWidget->setCentralRadial(point);
++ updateGradient(true);
++ }
++
++ void QtGradientEditorPrivate::slotFocalRadialXChanged(double value)
++ {
++ QPointF point = m_ui.gradientWidget->focalRadial();
++ point.setX(value);
++ m_ui.gradientWidget->setFocalRadial(point);
++ updateGradient(true);
++ }
++
++ void QtGradientEditorPrivate::slotFocalRadialYChanged(double value)
++ {
++ QPointF point = m_ui.gradientWidget->focalRadial();
++ point.setY(value);
++ m_ui.gradientWidget->setFocalRadial(point);
++ updateGradient(true);
++ }
++
++ void QtGradientEditorPrivate::slotRadiusRadialChanged(double value)
++ {
++ m_ui.gradientWidget->setRadiusRadial(value);
++ updateGradient(true);
++ }
++
++ void QtGradientEditorPrivate::slotCentralConicalXChanged(double value)
++ {
++ QPointF point = m_ui.gradientWidget->centralConical();
++ point.setX(value);
++ m_ui.gradientWidget->setCentralConical(point);
++ updateGradient(true);
++ }
++
++ void QtGradientEditorPrivate::slotCentralConicalYChanged(double value)
++ {
++ QPointF point = m_ui.gradientWidget->centralConical();
++ point.setY(value);
++ m_ui.gradientWidget->setCentralConical(point);
++ updateGradient(true);
++ }
++
++ void QtGradientEditorPrivate::slotAngleConicalChanged(double value)
++ {
++ m_ui.gradientWidget->setAngleConical(value);
++ updateGradient(true);
++ }
++
++ void QtGradientEditorPrivate::startLinearChanged(QPointF point)
++ {
++ setStartLinear(point);
++ updateGradient(true);
++ }
++
++ void QtGradientEditorPrivate::endLinearChanged(QPointF point)
++ {
++ setEndLinear(point);
++ updateGradient(true);
++ }
++
++ void QtGradientEditorPrivate::centralRadialChanged(QPointF point)
++ {
++ setCentralRadial(point);
++ updateGradient(true);
++ }
++
++ void QtGradientEditorPrivate::focalRadialChanged(QPointF point)
++ {
++ setFocalRadial(point);
++ updateGradient(true);
++ }
++
++ void QtGradientEditorPrivate::radiusRadialChanged(qreal radius)
++ {
++ setRadiusRadial(radius);
++ updateGradient(true);
++ }
++
++ void QtGradientEditorPrivate::centralConicalChanged(const QPointF &point)
++ {
++ setCentralConical(point);
++ updateGradient(true);
++ }
++
++ void QtGradientEditorPrivate::angleConicalChanged(qreal angle)
++ {
++ setAngleConical(angle);
++ updateGradient(true);
++ }
++
++ void QtGradientEditorPrivate::setStartLinear(QPointF point)
++ {
++ if (startLinearXSpinBox)
++ startLinearXSpinBox->setValue(point.x());
++ if (startLinearYSpinBox)
++ startLinearYSpinBox->setValue(point.y());
++ }
++
++ void QtGradientEditorPrivate::setEndLinear(QPointF point)
++ {
++ if (endLinearXSpinBox)
++ endLinearXSpinBox->setValue(point.x());
++ if (endLinearYSpinBox)
++ endLinearYSpinBox->setValue(point.y());
++ }
++
++ void QtGradientEditorPrivate::setCentralRadial(QPointF point)
++ {
++ if (centralRadialXSpinBox)
++ centralRadialXSpinBox->setValue(point.x());
++ if (centralRadialYSpinBox)
++ centralRadialYSpinBox->setValue(point.y());
++ }
++
++ void QtGradientEditorPrivate::setFocalRadial(QPointF point)
++ {
++ if (focalRadialXSpinBox)
++ focalRadialXSpinBox->setValue(point.x());
++ if (focalRadialYSpinBox)
++ focalRadialYSpinBox->setValue(point.y());
++ }
++
++ void QtGradientEditorPrivate::setRadiusRadial(qreal radius)
++ {
++ if (radiusRadialSpinBox)
++ radiusRadialSpinBox->setValue(radius);
++ }
++
++ void QtGradientEditorPrivate::setCentralConical(QPointF point)
++ {
++ if (centralConicalXSpinBox)
++ centralConicalXSpinBox->setValue(point.x());
++ if (centralConicalYSpinBox)
++ centralConicalYSpinBox->setValue(point.y());
++ }
++
++ void QtGradientEditorPrivate::setAngleConical(qreal angle)
++ {
++ if (angleConicalSpinBox)
++ angleConicalSpinBox->setValue(angle);
++ }
++
++ QtGradientEditor::QtGradientEditor(QWidget *parent)
++ : QWidget(parent), d_ptr(new QtGradientEditorPrivate(this))
++ {
++ }
++
++ QtGradientEditor::~QtGradientEditor()
++ {
++ if (d_ptr->m_hiddenWidget)
++ delete d_ptr->m_hiddenWidget;
++ }
++
++ void QtGradientEditor::setGradient(const QGradient &grad)
++ {
++ if (grad == gradient())
++ return;
++
++ QGradient::Type type = grad.type();
++ int idx = 0;
++ switch (type) {
++ case QGradient::LinearGradient: idx = 0; break;
++ case QGradient::RadialGradient: idx = 1; break;
++ case QGradient::ConicalGradient: idx = 2; break;
++ default: return;
++ }
++ d_ptr->setType(type);
++ d_ptr->m_ui.typeComboBox->setCurrentIndex(idx);
++ d_ptr->m_ui.gradientWidget->setGradientType(type);
++ d_ptr->m_typeGroup->button(idx)->setChecked(true);
++
++ QGradient::Spread spread = grad.spread();
++ switch (spread) {
++ case QGradient::PadSpread: idx = 0; break;
++ case QGradient::RepeatSpread: idx = 1; break;
++ case QGradient::ReflectSpread: idx = 2; break;
++ default: idx = 0; break;
++ }
++ d_ptr->m_ui.spreadComboBox->setCurrentIndex(idx);
++ d_ptr->m_ui.gradientWidget->setGradientSpread(spread);
++ d_ptr->m_spreadGroup->button(idx)->setChecked(true);
++
++ if (type == QGradient::LinearGradient) {
++ const QLinearGradient *gr = static_cast<const QLinearGradient *>(&grad);
++ d_ptr->setStartLinear(gr->start());
++ d_ptr->setEndLinear(gr->finalStop());
++ d_ptr->m_ui.gradientWidget->setStartLinear(gr->start());
++ d_ptr->m_ui.gradientWidget->setEndLinear(gr->finalStop());
++ } else if (type == QGradient::RadialGradient) {
++ const QRadialGradient *gr = static_cast<const QRadialGradient *>(&grad);
++ d_ptr->setCentralRadial(gr->center());
++ d_ptr->setFocalRadial(gr->focalPoint());
++ d_ptr->setRadiusRadial(gr->radius());
++ d_ptr->m_ui.gradientWidget->setCentralRadial(gr->center());
++ d_ptr->m_ui.gradientWidget->setFocalRadial(gr->focalPoint());
++ d_ptr->m_ui.gradientWidget->setRadiusRadial(gr->radius());
++ } else if (type == QGradient::ConicalGradient) {
++ const QConicalGradient *gr = static_cast<const QConicalGradient *>(&grad);
++ d_ptr->setCentralConical(gr->center());
++ d_ptr->setAngleConical(gr->angle());
++ d_ptr->m_ui.gradientWidget->setCentralConical(gr->center());
++ d_ptr->m_ui.gradientWidget->setAngleConical(gr->angle());
++ }
++
++ d_ptr->m_gradientStopsController->setGradientStops(grad.stops());
++ d_ptr->m_ui.gradientWidget->setGradientStops(grad.stops());
++ d_ptr->updateGradient(false);
++ }
++
++ QGradient QtGradientEditor::gradient() const
++ {
++ return d_ptr->m_gradient;
++ }
++
++ bool QtGradientEditor::isBackgroundCheckered() const
++ {
++ return d_ptr->m_backgroundCheckered;
++ }
++
++ void QtGradientEditor::setBackgroundCheckered(bool checkered)
++ {
++ if (d_ptr->m_backgroundCheckered == checkered)
++ return;
++
++ d_ptr->setBackgroundCheckered(checkered);
++ }
++
++ bool QtGradientEditor::detailsVisible() const
++ {
++ return d_ptr->m_details;
++ }
++
++ void QtGradientEditor::setDetailsVisible(bool visible)
++ {
++ if (d_ptr->m_details == visible)
++ return;
++
++ d_ptr->showDetails(visible);
++ }
++
++ bool QtGradientEditor::isDetailsButtonVisible() const
++ {
++ return d_ptr->m_detailsButtonVisible;
++ }
++
++ void QtGradientEditor::setDetailsButtonVisible(bool visible)
++ {
++ if (d_ptr->m_detailsButtonVisible == visible)
++ return;
++
++ d_ptr->m_detailsButtonVisible = visible;
++ d_ptr->m_ui.detailsButton->setVisible(visible);
++ }
++
++ QColor::Spec QtGradientEditor::spec() const
++ {
++ return d_ptr->m_gradientStopsController->spec();
++ }
++
++ void QtGradientEditor::setSpec(QColor::Spec spec)
++ {
++ d_ptr->m_gradientStopsController->setSpec(spec);
++ }
++
++ QT_END_NAMESPACE
++
++ #include "qtgradienteditor.moc"