File indexing completed on 2024-05-19 04:26:11

 /*
  *  SPDX-FileCopyrightText: 2010 Cyrille Berger <cberger@cberger.net>
  *  SPDX-FileCopyrightText: 2013 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #ifndef _KIS_DISTANCE_INFORMATION_H_
 #define _KIS_DISTANCE_INFORMATION_H_
 
 #include <QPointF>
 #include <QVector2D>
 #include <QDomDocument>
 #include <QDomElement>
 #include "kritaimage_export.h"
 #include <boost/optional.hpp>
 #include <boost/operators.hpp>
 
 class KisPaintInformation;
 class KisSpacingInformation;
 class KisTimingInformation;
 class KisDistanceInformation;
 
 /**
  * Represents some information that can be used to initialize a KisDistanceInformation object. The
  * main purpose of this class is to allow serialization of KisDistanceInformation initial settings
  * to XML.
  */
 class KRITAIMAGE_EXPORT KisDistanceInitInfo : boost::equality_comparable<KisDistanceInitInfo> {
 
 public:
 
     /**
      * Creates a KisDistanceInitInfo with no initial last dab information, and spacing and timing
      * update intervals set to LONG_TIME.
      */
     explicit KisDistanceInitInfo();
 
     /**
      * Creates a KisDistanceInitInfo with no initial last dab information, and the specified spacing
      * and timing update intervals.
      */
     explicit KisDistanceInitInfo(qreal spacingUpdateInterval, qreal timingUpdateInterval, int currentDabSeqNo);
 
     /**
      * Creates a KisDistanceInitInfo with the specified last dab information, and spacing and timing
      * update intervals set to LONG_TIME.
      */
     explicit KisDistanceInitInfo(const QPointF &lastPosition, qreal lastAngle, int currentDabSeqNo);
 
     /**
      * Creates a KisDistanceInitInfo with the specified last dab information and spacing and timing
      * update intervals.
      */
     explicit KisDistanceInitInfo(const QPointF &lastPosition, qreal lastAngle,
                                  qreal spacingUpdateInterval, qreal timingUpdateInterval, int currentDabSeqNo);
 
     KisDistanceInitInfo(const KisDistanceInitInfo &rhs);
 
     ~KisDistanceInitInfo();
 
     bool operator==(const KisDistanceInitInfo &other) const;
 
     KisDistanceInitInfo &operator=(const KisDistanceInitInfo &rhs);
 
     /**
      * Constructs a KisDistanceInformation with initial settings based on this object.
      */
     KisDistanceInformation makeDistInfo();
 
     void toXML(QDomDocument &doc, QDomElement &elt) const;
 
     static KisDistanceInitInfo fromXML(const QDomElement &elt);
 
 private:
     struct Private;
     Private * const m_d;
 };
 
 /**
  * This structure keeps track of distance and timing information during a stroke, e.g. the time or
  * distance moved since the last dab.
  */
 class KRITAIMAGE_EXPORT KisDistanceInformation {
 public:
     KisDistanceInformation();
     KisDistanceInformation(qreal spacingUpdateInterval, qreal timingUpdateInterval, int currentDabSeqNo = 0);
     KisDistanceInformation(const QPointF &lastPosition, qreal lastAngle);
     /**
      * @param spacingUpdateInterval The amount of time allowed between spacing updates, in
      *                              milliseconds. Use LONG_TIME to only allow spacing updates when a
      *                              dab is painted.
      * @param timingUpdateInterval The amount of time allowed between time-based spacing updates, in
      *                             milliseconds. Use LONG_TIME to only allow timing updates when a
      *                             dab is painted.
      */
     KisDistanceInformation(const QPointF &lastPosition, qreal lastAngle,
                            qreal spacingUpdateInterval, qreal timingUpdateInterval, int currentDabSeqNo);
     KisDistanceInformation(const KisDistanceInformation &rhs);
     KisDistanceInformation(const KisDistanceInformation &rhs, int levelOfDetail);
     KisDistanceInformation& operator=(const KisDistanceInformation &rhs);
 
     ~KisDistanceInformation();
 
     const KisSpacingInformation& currentSpacing() const;
     void updateSpacing(const KisSpacingInformation &spacing);
     /**
      * Returns true if this KisDistanceInformation should have its spacing information updated
      * immediately (regardless of whether a dab is ready to be painted).
      */
     bool needsSpacingUpdate() const;
 
     const KisTimingInformation &currentTiming() const;
     void updateTiming(const KisTimingInformation &timing);
     /**
      * Returns true if this KisDistanceInformation should have its timing information updated
      * immediately (regardless of whether a dab is ready to be painted).
      */
     bool needsTimingUpdate() const;
 
     bool hasLastDabInformation() const;
     QPointF lastPosition() const;
     qreal lastDrawingAngle() const;
 
     bool hasLastPaintInformation() const;
     const KisPaintInformation& lastPaintInformation() const;
 
     int currentDabSeqNo() const;
 
     qreal maxPressure() const;
 
     /**
      * @param spacing The new effective spacing after the dab. (Painting a dab is always supposed to
      *                cause a spacing update.)
      * @param timing The new effective timing after the dab. (Painting a dab is always supposed to
      *               cause a timing update.)
      */
     void registerPaintedDab(const KisPaintInformation &info,
                             const KisSpacingInformation &spacing,
                             const KisTimingInformation &timing);
 
     qreal getNextPointPosition(const QPointF &start,
                                const QPointF &end,
                                qreal startTime,
                                qreal endTime);
 
     qreal getSpacingInterval() const;
     qreal getTimingUpdateInterval() const;
 
     /**
      * \return true if at least one dab has been painted with this
      *         distance information
      */
     bool isStarted() const;
 
     boost::optional<qreal> lockedDrawingAngleOptional() const;
 
     /**
      * Lock current drawing angle for the rest of the stroke. The new value is blended
      * into the result proportional to the length of the stroke.
      */
     void lockCurrentDrawingAngle(const KisPaintInformation &info) const;
 
     qreal scalarDistanceApprox() const;
 
     void overrideLastValues(const QPointF &lastPosition, qreal lastAngle);
 
 private:
     qreal getNextPointPositionIsotropic(const QPointF &start,
                                         const QPointF &end);
     qreal getNextPointPositionAnisotropic(const QPointF &start,
                                           const QPointF &end);
     qreal getNextPointPositionTimed(qreal startTime,
                                     qreal endTime);
     void resetAccumulators();
 
 private:
     struct Private;
     Private * const m_d;
 };
 
 #endif