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 "qtgradientstopsmodel_p.h"
++
++ #include <QtGui/qcolor.h>
++
++ #include <QtCore/qhash.h>
++
++ QT_BEGIN_NAMESPACE
++
++ class QtGradientStopPrivate
++ {
++ public:
++ qreal m_position = 0;
++ QColor m_color = Qt::white;
++ QtGradientStopsModel *m_model = nullptr;
++ };
++
++ qreal QtGradientStop::position() const
++ {
++ return d_ptr->m_position;
++ }
++
++ QColor QtGradientStop::color() const
++ {
++ return d_ptr->m_color;
++ }
++
++ QtGradientStopsModel *QtGradientStop::gradientModel() const
++ {
++ return d_ptr->m_model;
++ }
++
++ void QtGradientStop::setColor(QColor color)
++ {
++ d_ptr->m_color = color;
++ }
++
++ void QtGradientStop::setPosition(qreal position)
++ {
++ d_ptr->m_position = position;
++ }
++
++ QtGradientStop::QtGradientStop(QtGradientStopsModel *model)
++ : d_ptr(new QtGradientStopPrivate())
++ {
++ d_ptr->m_model = model;
++ }
++
++ QtGradientStop::~QtGradientStop()
++ {
++ }
++
++ class QtGradientStopsModelPrivate
++ {
++ QtGradientStopsModel *q_ptr = nullptr;
++ Q_DECLARE_PUBLIC(QtGradientStopsModel)
++ public:
++ QMap<qreal, QtGradientStop *> m_posToStop;
++ QHash<QtGradientStop *, qreal> m_stopToPos;
++ QHash<QtGradientStop *, bool> m_selection;
++ QtGradientStop *m_current = nullptr;
++ };
++
++
++
++ QtGradientStopsModel::QtGradientStopsModel(QObject *parent)
++ : QObject(parent), d_ptr(new QtGradientStopsModelPrivate)
++ {
++ d_ptr->q_ptr = this;
++ }
++
++ QtGradientStopsModel::~QtGradientStopsModel()
++ {
++ clear();
++ }
++
++ QtGradientStopsModel::PositionStopMap QtGradientStopsModel::stops() const
++ {
++ return d_ptr->m_posToStop;
++ }
++
++ QtGradientStop *QtGradientStopsModel::at(qreal pos) const
++ {
++ if (d_ptr->m_posToStop.contains(pos))
++ return d_ptr->m_posToStop[pos];
++ return 0;
++ }
++
++ QColor QtGradientStopsModel::color(qreal pos) const
++ {
++ PositionStopMap gradStops = stops();
++ if (gradStops.isEmpty())
++ return QColor::fromRgbF(pos, pos, pos, 1.0);
++ if (gradStops.contains(pos))
++ return gradStops[pos]->color();
++
++ gradStops[pos] = 0;
++ auto itStop = gradStops.constFind(pos);
++ if (itStop == gradStops.constBegin()) {
++ ++itStop;
++ return itStop.value()->color();
++ }
++ if (itStop == --gradStops.constEnd()) {
++ --itStop;
++ return itStop.value()->color();
++ }
++ auto itPrev = itStop;
++ auto itNext = itStop;
++ --itPrev;
++ ++itNext;
++
++ double prevX = itPrev.key();
++ double nextX = itNext.key();
++
++ double coefX = (pos - prevX) / (nextX - prevX);
++ QColor prevCol = itPrev.value()->color();
++ QColor nextCol = itNext.value()->color();
++
++ QColor newColor;
++ newColor.setRgbF((nextCol.redF() - prevCol.redF() ) * coefX + prevCol.redF(),
++ (nextCol.greenF() - prevCol.greenF()) * coefX + prevCol.greenF(),
++ (nextCol.blueF() - prevCol.blueF() ) * coefX + prevCol.blueF(),
++ (nextCol.alphaF() - prevCol.alphaF()) * coefX + prevCol.alphaF());
++ return newColor;
++ }
++
++ QList<QtGradientStop *> QtGradientStopsModel::selectedStops() const
++ {
++ return d_ptr->m_selection.keys();
++ }
++
++ QtGradientStop *QtGradientStopsModel::currentStop() const
++ {
++ return d_ptr->m_current;
++ }
++
++ bool QtGradientStopsModel::isSelected(QtGradientStop *stop) const
++ {
++ if (d_ptr->m_selection.contains(stop))
++ return true;
++ return false;
++ }
++
++ QtGradientStop *QtGradientStopsModel::addStop(qreal pos, QColor color)
++ {
++ qreal newPos = pos;
++ if (pos < 0.0)
++ newPos = 0.0;
++ if (pos > 1.0)
++ newPos = 1.0;
++ if (d_ptr->m_posToStop.contains(newPos))
++ return 0;
++ QtGradientStop *stop = new QtGradientStop();
++ stop->setPosition(newPos);
++ stop->setColor(color);
++
++ d_ptr->m_posToStop[newPos] = stop;
++ d_ptr->m_stopToPos[stop] = newPos;
++
++ emit stopAdded(stop);
++
++ return stop;
++ }
++
++ void QtGradientStopsModel::removeStop(QtGradientStop *stop)
++ {
++ if (!d_ptr->m_stopToPos.contains(stop))
++ return;
++ if (currentStop() == stop)
++ setCurrentStop(0);
++ selectStop(stop, false);
++
++ emit stopRemoved(stop);
++
++ qreal pos = d_ptr->m_stopToPos[stop];
++ d_ptr->m_stopToPos.remove(stop);
++ d_ptr->m_posToStop.remove(pos);
++ delete stop;
++ }
++
++ void QtGradientStopsModel::moveStop(QtGradientStop *stop, qreal newPos)
++ {
++ if (!d_ptr->m_stopToPos.contains(stop))
++ return;
++ if (d_ptr->m_posToStop.contains(newPos))
++ return;
++
++ if (newPos > 1.0)
++ newPos = 1.0;
++ else if (newPos < 0.0)
++ newPos = 0.0;
++
++ emit stopMoved(stop, newPos);
++
++ const qreal oldPos = stop->position();
++ stop->setPosition(newPos);
++ d_ptr->m_stopToPos[stop] = newPos;
++ d_ptr->m_posToStop.remove(oldPos);
++ d_ptr->m_posToStop[newPos] = stop;
++ }
++
++ void QtGradientStopsModel::swapStops(QtGradientStop *stop1, QtGradientStop *stop2)
++ {
++ if (stop1 == stop2)
++ return;
++ if (!d_ptr->m_stopToPos.contains(stop1))
++ return;
++ if (!d_ptr->m_stopToPos.contains(stop2))
++ return;
++
++ emit stopsSwapped(stop1, stop2);
++
++ const qreal pos1 = stop1->position();
++ const qreal pos2 = stop2->position();
++ stop1->setPosition(pos2);
++ stop2->setPosition(pos1);
++ d_ptr->m_stopToPos[stop1] = pos2;
++ d_ptr->m_stopToPos[stop2] = pos1;
++ d_ptr->m_posToStop[pos1] = stop2;
++ d_ptr->m_posToStop[pos2] = stop1;
++ }
++
++ void QtGradientStopsModel::changeStop(QtGradientStop *stop, QColor newColor)
++ {
++ if (!d_ptr->m_stopToPos.contains(stop))
++ return;
++ if (stop->color() == newColor)
++ return;
++
++ emit stopChanged(stop, newColor);
++
++ stop->setColor(newColor);
++ }
++
++ void QtGradientStopsModel::selectStop(QtGradientStop *stop, bool select)
++ {
++ if (!d_ptr->m_stopToPos.contains(stop))
++ return;
++ bool selected = d_ptr->m_selection.contains(stop);
++ if (select == selected)
++ return;
++
++ emit stopSelected(stop, select);
++
++ if (select)
++ d_ptr->m_selection[stop] = true;
++ else
++ d_ptr->m_selection.remove(stop);
++ }
++
++ void QtGradientStopsModel::setCurrentStop(QtGradientStop *stop)
++ {
++ if (stop && !d_ptr->m_stopToPos.contains(stop))
++ return;
++ if (stop == currentStop())
++ return;
++
++ emit currentStopChanged(stop);
++
++ d_ptr->m_current = stop;
++ }
++
++ QtGradientStop *QtGradientStopsModel::firstSelected() const
++ {
++ PositionStopMap stopList = stops();
++ auto itStop = stopList.cbegin();
++ while (itStop != stopList.constEnd()) {
++ QtGradientStop *stop = itStop.value();
++ if (isSelected(stop))
++ return stop;
++ ++itStop;
++ };
++ return 0;
++ }
++
++ QtGradientStop *QtGradientStopsModel::lastSelected() const
++ {
++ PositionStopMap stopList = stops();
++ auto itStop = stopList.cend();
++ while (itStop != stopList.constBegin()) {
++ --itStop;
++
++ QtGradientStop *stop = itStop.value();
++ if (isSelected(stop))
++ return stop;
++ };
++ return 0;
++ }
++
++ QtGradientStopsModel *QtGradientStopsModel::clone() const
++ {
++ QtGradientStopsModel *model = new QtGradientStopsModel();
++
++ QMap<qreal, QtGradientStop *> stopsToClone = stops();
++ for (auto it = stopsToClone.cbegin(), end = stopsToClone.cend(); it != end; ++it)
++ model->addStop(it.key(), it.value()->color());
++ // clone selection and current also
++ return model;
++ }
++
++ void QtGradientStopsModel::moveStops(double newPosition)
++ {
++ QtGradientStop *current = currentStop();
++ if (!current)
++ return;
++
++ double newPos = newPosition;
++
++ if (newPos > 1)
++ newPos = 1;
++ else if (newPos < 0)
++ newPos = 0;
++
++ if (newPos == current->position())
++ return;
++
++ double offset = newPos - current->position();
++
++ QtGradientStop *first = firstSelected();
++ QtGradientStop *last = lastSelected();
++
++ if (first && last) { // multiselection
++ double maxOffset = 1.0 - last->position();
++ double minOffset = -first->position();
++
++ if (offset > maxOffset)
++ offset = maxOffset;
++ else if (offset < minOffset)
++ offset = minOffset;
++
++ }
++
++ if (offset == 0)
++ return;
++
++ bool forward = (offset > 0) ? false : true;
++
++ PositionStopMap stopList;
++
++ const auto selected = selectedStops();
++ for (QtGradientStop *stop : selected)
++ stopList[stop->position()] = stop;
++ stopList[current->position()] = current;
++
++ auto itStop = forward ? stopList.cbegin() : stopList.cend();
++ while (itStop != (forward ? stopList.constEnd() : stopList.constBegin())) {
++ if (!forward)
++ --itStop;
++ QtGradientStop *stop = itStop.value();
++ double pos = stop->position() + offset;
++ if (pos > 1)
++ pos = 1;
++ if (pos < 0)
++ pos = 0;
++
++ if (current == stop)
++ pos = newPos;
++
++ QtGradientStop *oldStop = at(pos);
++ if (oldStop && !stopList.values().contains(oldStop))
++ removeStop(oldStop);
++ moveStop(stop, pos);
++
++ if (forward)
++ ++itStop;
++ }
++ }
++
++ void QtGradientStopsModel::clear()
++ {
++ const auto stopsList = stops().values();
++ for (QtGradientStop *stop : stopsList)
++ removeStop(stop);
++ }
++
++ void QtGradientStopsModel::clearSelection()
++ {
++ const auto stopsList = selectedStops();
++ for (QtGradientStop *stop : stopsList)
++ selectStop(stop, false);
++ }
++
++ void QtGradientStopsModel::flipAll()
++ {
++ QMap<qreal, QtGradientStop *> stopsMap = stops();
++ QHash<QtGradientStop *, bool> swappedList;
++ for (auto itStop = stopsMap.keyValueEnd(), begin = stopsMap.keyValueBegin(); itStop != begin;) {
++ --itStop;
++ QtGradientStop *stop = (*itStop).second;
++ if (swappedList.contains(stop))
++ continue;
++ const double newPos = 1.0 - (*itStop).first;
++ if (stopsMap.contains(newPos)) {
++ QtGradientStop *swapped = stopsMap.value(newPos);
++ swappedList[swapped] = true;
++ swapStops(stop, swapped);
++ } else {
++ moveStop(stop, newPos);
++ }
++ }
++ }
++
++ void QtGradientStopsModel::selectAll()
++ {
++ const auto stopsMap = stops();
++ for (auto it = stopsMap.cbegin(), end = stopsMap.cend(); it != end; ++it)
++ selectStop(it.value(), true);
++ }
++
++ void QtGradientStopsModel::deleteStops()
++ {
++ const auto selected = selectedStops();
++ for (QtGradientStop *stop : selected)
++ removeStop(stop);
++ QtGradientStop *current = currentStop();
++ if (current)
++ removeStop(current);
++ }
++
++ QT_END_NAMESPACE