File indexing completed on 2024-06-23 04:27:03

 /* This file is part of the KDE project
  * SPDX-FileCopyrightText: 2007, 2010, 2011 Jan Hambrecht <jaham@gmx.net>
  * SPDX-FileCopyrightText: 2009-2010 Thomas Zander <zander@kde.org>
  * SPDX-FileCopyrightText: 2010 Carlos Licea <carlos@kdab.com>
  * SPDX-FileCopyrightText: 2010 Nokia Corporation and /or its subsidiary(-ies).
  *   Contact: Suresh Chande suresh.chande@nokia.com
  * SPDX-FileCopyrightText: 2009-2010 Thorsten Zachmann <zachmann@kde.org>
  *
  * SPDX-License-Identifier: LGPL-2.0-or-later
  */
 
 #include <KoParameterShape_p.h>
 
 #include "EnhancedPathShape.h"
 #include "EnhancedPathCommand.h"
 #include "EnhancedPathParameter.h"
 #include "EnhancedPathHandle.h"
 #include "EnhancedPathFormula.h"
 
 #include <QPainterPath>
 
 #include <KoXmlNS.h>
 #include <KoXmlWriter.h>
 #include <KoShapeSavingContext.h>
 #include <KoUnit.h>
 #include <KoPathPoint.h>
 
 EnhancedPathShape::EnhancedPathShape(const QRect &viewBox)
     : m_viewBox(viewBox)
     , m_viewBoxOffset(0.0, 0.0)
     , m_mirrorVertically(false)
     , m_mirrorHorizontally(false)
     , m_pathStretchPointX(-1)
     , m_pathStretchPointY(-1)
     , m_cacheResults(false)
 {
 }
 
 EnhancedPathShape::EnhancedPathShape(const EnhancedPathShape &rhs)
     : KoParameterShape(rhs),
       m_viewBox(rhs.m_viewBox),
       m_viewBound(rhs.m_viewBound),
       m_viewMatrix(rhs.m_viewMatrix),
       m_mirrorMatrix(rhs.m_mirrorMatrix),
       m_viewBoxOffset(rhs.m_viewBoxOffset),
       m_textArea(rhs.m_textArea),
       m_commands(rhs.m_commands),
       m_enhancedHandles(rhs.m_enhancedHandles),
       m_formulae(rhs.m_formulae),
       m_modifiers(rhs.m_modifiers),
       m_parameters(rhs.m_parameters),
       m_mirrorVertically(rhs.m_mirrorVertically),
       m_mirrorHorizontally(rhs.m_mirrorHorizontally),
       m_pathStretchPointX(rhs.m_pathStretchPointX),
       m_pathStretchPointY(rhs.m_pathStretchPointY),
       m_resultCache(rhs.m_resultCache),
       m_cacheResults(rhs.m_cacheResults)
 {
 }
 
 EnhancedPathShape::~EnhancedPathShape()
 {
     reset();
 }
 
 KoShape *EnhancedPathShape::cloneShape() const
 {
     return new EnhancedPathShape(*this);
 }
 
 void EnhancedPathShape::reset()
 {
     qDeleteAll(m_commands);
     m_commands.clear();
     qDeleteAll(m_enhancedHandles);
     m_enhancedHandles.clear();
     setHandles(QList<QPointF>());
     qDeleteAll(m_formulae);
     m_formulae.clear();
     qDeleteAll(m_parameters);
     m_parameters.clear();
     m_modifiers.clear();
     m_viewMatrix.reset();
     m_viewBoxOffset = QPointF();
     clear();
     m_textArea.clear();
 }
 
 void EnhancedPathShape::moveHandleAction(int handleId, const QPointF &point, Qt::KeyboardModifiers modifiers)
 {
     Q_UNUSED(modifiers);
     EnhancedPathHandle *handle = m_enhancedHandles[ handleId ];
     if (handle) {
         handle->changePosition(shapeToViewbox(point));
     }
 }
 
 void EnhancedPathShape::updatePath(const QSizeF &size)
 {
     if (isParametricShape()) {
         clear();
         enableResultCache(true);
 
         foreach (EnhancedPathCommand *cmd, m_commands) {
             cmd->execute();
         }
 
         enableResultCache(false);
 
         qreal stretchPointsScale = 1;
         bool isStretched = useStretchPoints(size, stretchPointsScale);
         m_viewBound = outline().boundingRect();
         m_mirrorMatrix.reset();
         m_mirrorMatrix.translate(m_viewBound.center().x(), m_viewBound.center().y());
         m_mirrorMatrix.scale(m_mirrorHorizontally ? -1 : 1, m_mirrorVertically ? -1 : 1);
         m_mirrorMatrix.translate(-m_viewBound.center().x(), -m_viewBound.center().y());
         QTransform matrix(1.0, 0.0, 0.0, 1.0, m_viewBoxOffset.x(), m_viewBoxOffset.y());
 
         // if stretch points are set than stretch the path manually
         if (isStretched) {
             //if the path was stretched manually the stretch matrix is not more valid
             //and it has to be recalculated so that stretching in x and y direction is the same
             matrix.scale(stretchPointsScale, stretchPointsScale);
             matrix = m_mirrorMatrix * matrix;
         } else {
             matrix = m_mirrorMatrix * m_viewMatrix * matrix;
         }
         foreach (KoSubpath *subpath, subpaths()) {
             foreach (KoPathPoint *point, *subpath) {
                 point->map(matrix);
             }
         }
 
         const int handleCount = m_enhancedHandles.count();
         QList<QPointF> handles;
         for (int i = 0; i < handleCount; ++i) {
             handles.append(matrix.map(m_enhancedHandles[i]->position()));
         }
         setHandles(handles);
 
         normalize();
     }
 }
 
 void EnhancedPathShape::setSize(const QSizeF &newSize)
 {
     // handle offset
     KoParameterShape::setSize(newSize);
 
     // calculate scaling factors from viewbox size to shape size
     qreal xScale = m_viewBound.width() == 0 ? 1 : newSize.width() / m_viewBound.width();
     qreal yScale = m_viewBound.height() == 0 ? 1 : newSize.height() / m_viewBound.height();
 
     // create view matrix, take mirroring into account
     m_viewMatrix.reset();
     m_viewMatrix.scale(xScale, yScale);
 
     updatePath(newSize);
 }
 
 QPointF EnhancedPathShape::normalize()
 {
     QPointF offset = KoParameterShape::normalize();
 
     m_viewBoxOffset -= offset;
 
     return offset;
 }
 
 QPointF EnhancedPathShape::shapeToViewbox(const QPointF &point) const
 {
     return (m_mirrorMatrix * m_viewMatrix).inverted().map(point - m_viewBoxOffset);
 }
 
 void EnhancedPathShape::evaluateHandles()
 {
     const int handleCount = m_enhancedHandles.count();
     QList<QPointF> handles;
     for (int i = 0; i < handleCount; ++i) {
         handles.append(m_enhancedHandles[i]->position());
     }
     setHandles(handles);
 }
 
 QRect EnhancedPathShape::viewBox() const
 {
     return m_viewBox;
 }
 
 qreal EnhancedPathShape::evaluateReference(const QString &reference)
 {
     if (reference.isEmpty()) {
         return 0.0;
     }
 
     const char c = reference[0].toLatin1();
 
     qreal res = 0.0;
 
     switch (c) {
     // referenced modifier
     case '$': {
         bool success = false;
         int modifierIndex = reference.mid(1).toInt(&success);
         res = m_modifiers.value(modifierIndex);
         break;
     }
     // referenced formula
     case '?': {
         QString fname = reference.mid(1);
         if (m_cacheResults && m_resultCache.contains(fname)) {
             res = m_resultCache.value(fname);
         } else {
             FormulaStore::const_iterator formulaIt = m_formulae.constFind(fname);
             if (formulaIt != m_formulae.constEnd()) {
                 EnhancedPathFormula *formula = formulaIt.value();
                 if (formula) {
                     res = formula->evaluate();
                     if (m_cacheResults) {
                         m_resultCache.insert(fname, res);
                     }
                 }
             }
         }
         break;
     }
     // maybe an identifier ?
     default:
         EnhancedPathNamedParameter p(reference, this);
         res = p.evaluate();
         break;
     }
 
     return res;
 }
 
 qreal EnhancedPathShape::evaluateConstantOrReference(const QString &val)
 {
     bool ok = true;
     qreal res = val.toDouble(&ok);
     if (ok) {
         return res;
     }
     return evaluateReference(val);
 }
 
 void EnhancedPathShape::modifyReference(const QString &reference, qreal value)
 {
     if (reference.isEmpty()) {
         return;
     }
 
     const char c = reference[0].toLatin1();
 
     if (c == '$') {
         bool success = false;
         int modifierIndex = reference.mid(1).toInt(&success);
         if (modifierIndex >= 0 && modifierIndex < m_modifiers.count()) {
             m_modifiers[modifierIndex] = value;
         }
     }
 }
 
 EnhancedPathParameter *EnhancedPathShape::parameter(const QString &text)
 {
     Q_ASSERT(! text.isEmpty());
 
     ParameterStore::const_iterator parameterIt = m_parameters.constFind(text);
     if (parameterIt != m_parameters.constEnd()) {
         return parameterIt.value();
     } else {
         EnhancedPathParameter *parameter = 0;
         const char c = text[0].toLatin1();
         if (c == '$' || c == '?') {
             parameter = new EnhancedPathReferenceParameter(text, this);
         } else {
             bool success = false;
             qreal constant = text.toDouble(&success);
             if (success) {
                 parameter = new EnhancedPathConstantParameter(constant, this);
             } else {
                 Identifier identifier = EnhancedPathNamedParameter::identifierFromString(text);
                 if (identifier != IdentifierUnknown) {
                     parameter = new EnhancedPathNamedParameter(identifier, this);
                 }
             }
         }
 
         if (parameter) {
             m_parameters[text] = parameter;
         }
 
         return parameter;
     }
 }
 
 void EnhancedPathShape::addFormula(const QString &name, const QString &formula)
 {
     if (name.isEmpty() || formula.isEmpty()) {
         return;
     }
 
     m_formulae[name] = new EnhancedPathFormula(formula, this);
 }
 
 void EnhancedPathShape::addHandle(const QMap<QString, QVariant> &handle)
 {
     if (handle.isEmpty()) {
         return;
     }
 
     if (!handle.contains("draw:handle-position")) {
         return;
     }
     QVariant position = handle.value("draw:handle-position");
 
     QStringList tokens = position.toString().simplified().split(' ');
     if (tokens.count() < 2) {
         return;
     }
 
     EnhancedPathHandle *newHandle = new EnhancedPathHandle(this);
     newHandle->setPosition(parameter(tokens[0]), parameter(tokens[1]));
 
     // check if we have a polar handle
     if (handle.contains("draw:handle-polar")) {
         QVariant polar = handle.value("draw:handle-polar");
         QStringList tokens = polar.toString().simplified().split(' ');
         if (tokens.count() == 2) {
             newHandle->setPolarCenter(parameter(tokens[0]), parameter(tokens[1]));
 
             QVariant minRadius = handle.value("draw:handle-radius-range-minimum");
             QVariant maxRadius = handle.value("draw:handle-radius-range-maximum");
             if (minRadius.isValid() && maxRadius.isValid()) {
                 newHandle->setRadiusRange(parameter(minRadius.toString()), parameter(maxRadius.toString()));
             }
         }
     } else {
         QVariant minX = handle.value("draw:handle-range-x-minimum");
         QVariant maxX = handle.value("draw:handle-range-x-maximum");
         if (minX.isValid() && maxX.isValid()) {
             newHandle->setRangeX(parameter(minX.toString()), parameter(maxX.toString()));
         }
 
         QVariant minY = handle.value("draw:handle-range-y-minimum");
         QVariant maxY = handle.value("draw:handle-range-y-maximum");
         if (minY.isValid() && maxY.isValid()) {
             newHandle->setRangeY(parameter(minY.toString()), parameter(maxY.toString()));
         }
     }
 
     m_enhancedHandles.append(newHandle);
 
     evaluateHandles();
 }
 
 void EnhancedPathShape::addModifiers(const QString &modifiers)
 {
     if (modifiers.isEmpty()) {
         return;
     }
 
     QStringList tokens = modifiers.simplified().split(' ');
     int tokenCount = tokens.count();
     for (int i = 0; i < tokenCount; ++i) {
         m_modifiers.append(tokens[i].toDouble());
     }
 }
 
 void EnhancedPathShape::addCommand(const QString &command)
 {
     addCommand(command, true);
 }
 
 void EnhancedPathShape::addCommand(const QString &command, bool triggerUpdate)
 {
     QString commandStr = command.simplified();
     if (commandStr.isEmpty()) {
         return;
     }
 
     // the first character is the command
     EnhancedPathCommand *cmd = new EnhancedPathCommand(commandStr[0], this);
 
     // strip command char
     commandStr = commandStr.mid(1).simplified();
 
     // now parse the command parameters
     if (!commandStr.isEmpty()) {
         QStringList tokens = commandStr.split(' ');
         for (int i = 0; i < tokens.count(); ++i) {
             cmd->addParameter(parameter(tokens[i]));
         }
     }
     m_commands.append(cmd);
 
     if (triggerUpdate) {
         updatePath(size());
     }
 }
 
 bool EnhancedPathShape::useStretchPoints(const QSizeF &size, qreal &scale)
 {
     bool retval = false;
     if (m_pathStretchPointX != -1 && m_pathStretchPointY != -1) {
         qreal scaleX = size.width();
         qreal scaleY = size.height();
         if (qreal(m_viewBox.width()) / m_viewBox.height() < qreal(scaleX) / scaleY) {
             qreal deltaX = (scaleX * m_viewBox.height()) / scaleY - m_viewBox.width();
             foreach (KoSubpath *subpath, subpaths()) {
                 foreach (KoPathPoint *currPoint, *subpath) {
                     if (currPoint->point().x() >=  m_pathStretchPointX &&
                             currPoint->controlPoint1().x() >= m_pathStretchPointX &&
                             currPoint->controlPoint2().x() >= m_pathStretchPointX) {
                         currPoint->setPoint(QPointF(currPoint->point().x() + deltaX, currPoint->point().y()));
                         currPoint->setControlPoint1(QPointF(currPoint->controlPoint1().x() + deltaX,
                                                             currPoint->controlPoint1().y()));
                         currPoint->setControlPoint2(QPointF(currPoint->controlPoint2().x() + deltaX,
                                                             currPoint->controlPoint2().y()));
                         retval = true;
                     }
                 }
             }
             scale = scaleY / m_viewBox.height();
         } else if (qreal(m_viewBox.width()) / m_viewBox.height() > qreal(scaleX) / scaleY) {
             qreal deltaY = (m_viewBox.width() * scaleY) / scaleX - m_viewBox.height();
             foreach (KoSubpath *subpath, subpaths()) {
                 foreach (KoPathPoint *currPoint, *subpath) {
                     if (currPoint->point().y() >=  m_pathStretchPointY &&
                             currPoint->controlPoint1().y() >= m_pathStretchPointY &&
                             currPoint->controlPoint2().y() >= m_pathStretchPointY) {
                         currPoint->setPoint(QPointF(currPoint->point().x(), currPoint->point().y() + deltaY));
                         currPoint->setControlPoint1(QPointF(currPoint->controlPoint1().x(),
                                                             currPoint->controlPoint1().y() + deltaY));
                         currPoint->setControlPoint2(QPointF(currPoint->controlPoint2().x(),
                                                             currPoint->controlPoint2().y() + deltaY));
                         retval = true;
                     }
                 }
             }
             scale = scaleX / m_viewBox.width();
         }
 
         notifyPointsChanged();
     }
     return retval;
 }
 
 void EnhancedPathShape::parsePathData(const QString &data)
 {
     if (data.isEmpty()) {
         return;
     }
 
     int start = -1;
     bool separator = true;
     for (int i = 0; i < data.length(); ++i) {
         QChar ch = data.at(i);
         ushort uni_ch = ch.unicode();
         if (separator && (uni_ch == 'M' || uni_ch == 'L'
                           || uni_ch == 'C' || uni_ch == 'Z'
                           || uni_ch == 'N' || uni_ch == 'F'
                           || uni_ch == 'S' || uni_ch == 'T'
                           || uni_ch == 'U' || uni_ch == 'A'
                           || uni_ch == 'B' || uni_ch == 'W'
                           || uni_ch == 'V' || uni_ch == 'X'
                           || uni_ch == 'Y' || uni_ch == 'Q')) {
             if (start != -1) { // process last chars
                 addCommand(data.mid(start, i - start), false);
             }
             start = i;
         }
         separator = ch.isSpace();
     }
     if (start < data.length()) {
         addCommand(data.mid(start));
     }
     if (start != -1) {
         updatePath(size());
     }
 }
 
 void EnhancedPathShape::setMirrorHorizontally(bool mirrorHorizontally)
 {
     if (m_mirrorHorizontally != mirrorHorizontally) {
         m_mirrorHorizontally = mirrorHorizontally;
         updatePath(size());
     }
 
 }
 
 void EnhancedPathShape::setMirrorVertically(bool mirrorVertically)
 {
     if (m_mirrorVertically != mirrorVertically) {
         m_mirrorVertically = mirrorVertically;
         updatePath(size());
     }
 }
 
 void EnhancedPathShape::shapeChanged(ChangeType type, KoShape *shape)
 {
     KoParameterShape::shapeChanged(type, shape);
 
     if (!shape || shape == this) {
         if (type == ParentChanged || type == ParameterChanged) {
             updateTextArea();
         }
     }
 }
 
 void EnhancedPathShape::updateTextArea()
 {
     if (m_textArea.size() >= 4) {
         QRectF r = m_viewBox;
         r.setLeft(evaluateConstantOrReference(m_textArea[0]));
         r.setTop(evaluateConstantOrReference(m_textArea[1]));
         r.setRight(evaluateConstantOrReference(m_textArea[2]));
         r.setBottom(evaluateConstantOrReference(m_textArea[3]));
         r = m_viewMatrix.mapRect(r).translated(m_viewBoxOffset);
         setPreferredTextRect(r);
     }
 }
 
 void EnhancedPathShape::enableResultCache(bool enable)
 {
     m_resultCache.clear();
     m_cacheResults = enable;
 }
 
 void EnhancedPathShape::setPathStretchPointX(qreal pathStretchPointX)
 {
     if (m_pathStretchPointX != pathStretchPointX) {
         m_pathStretchPointX = pathStretchPointX;
     }
 
 }
 
 void EnhancedPathShape::setPathStretchPointY(qreal pathStretchPointY)
 {
     if (m_pathStretchPointY != pathStretchPointY) {
         m_pathStretchPointY = pathStretchPointY;
     }
 
 }