File indexing completed on 2024-05-12 04:44:33

 // SPDX-FileCopyrightText: Lukas Sommer <sommerluk@gmail.com>
 // SPDX-License-Identifier: BSD-2-Clause OR MIT
 
 #ifndef GRADIENTIMAGEPARAMETERS_H
 #define GRADIENTIMAGEPARAMETERS_H
 
 #include "lchadouble.h"
 #include <qglobal.h>
 #include <qimage.h>
 #include <qmetatype.h>
 #include <qsharedpointer.h>
 #include <qvariant.h>
 
 namespace PerceptualColor
 {
 class AsyncImageRenderCallback;
 class RgbColorSpace;
 
 /** @internal
  *
  *  @brief Parameters for image of a gradient.
  *
  * For usage with @ref AsyncImageProvider.
  *
  * As the hue is a circular property, there exists two ways to go one hue to
  * another (clockwise or counter-clockwise). This gradient takes always the
  * shortest way.
  *
  * The image has properties that can be accessed by the corresponding setters
  * and getters or directly. You should explicitly set all values
  * <em>before</em> calling the first time @ref render().
  *
  * This class supports HiDPI via its @ref setDevicePixelRatioF function.
  *
  * @todo Instead of providing an image that has actually the size that
  * has been requested, we could provide just a tile. The user would have
  * to tile the surface. In many cases, we could get away with much smaller
  * images. Attention: Test if this approach works fine when the screen scale
  * factor is not an integer! */
 struct GradientImageParameters final {
 public:
     explicit GradientImageParameters();
     [[nodiscard]] bool operator==(const GradientImageParameters &other) const;
     [[nodiscard]] bool operator!=(const GradientImageParameters &other) const;
 
     /** @brief Pointer to @ref RgbColorSpace object */
     QSharedPointer<PerceptualColor::RgbColorSpace> rgbColorSpace = nullptr;
 
     [[nodiscard]] LchaDouble colorFromValue(qreal value) const;
     static void render(const QVariant &variantParameters, AsyncImageRenderCallback &callbackObject);
     void setDevicePixelRatioF(const qreal newDevicePixelRatioF);
     void setFirstColor(const LchaDouble &newFirstColor);
     void setGradientLength(const int newGradientLength);
     void setGradientThickness(const int newGradientThickness);
     void setSecondColor(const LchaDouble &newFirstColor);
 
 private:
     /** @internal @brief Only for unit tests. */
     friend class TestGradientImageParameters;
 
     // Methods
     [[nodiscard]] static LchaDouble completlyNormalizedAndBounded(const LchaDouble &color);
     void updateSecondColor();
 
     // Data members
     /** @brief Internal storage of the device pixel ratio as floating point.
      *
      * @sa @ref setDevicePixelRatioF() */
     qreal m_devicePixelRatioF = 1;
     /** @brief Internal storage of the first color.
      *
      * The color is normalized and bound to the LCH color space.
      * @sa @ref completlyNormalizedAndBounded() */
     LchaDouble m_firstColorCorrected;
     /** @brief Internal storage for the gradient length, measured in
      * physical pixels.
      *
      * @sa @ref setGradientLength() */
     int m_gradientLength = 0;
     /** @brief Internal storage for the gradient thickness, measured in
      * physical pixels.
      *
      * @sa @ref setGradientThickness() */
     int m_gradientThickness = 0;
     /** @brief Internal storage of the image (cache).
      *
      * - If <tt>m_image.isNull()</tt> than either no cache is available
      *   or @ref m_gradientLength or @ref m_gradientThickness is <tt>0</tt>.
      *   Before using it, a new image has to be rendered. (If
      *   @ref m_gradientLength or @ref m_gradientThickness is
      *   <tt>0</tt>, this will be extremly fast.)
      * - If <tt>m_image.isNull()</tt> is <tt>false</tt>, than the cache
      *   is valid and can be used directly. */
     QImage m_image;
     /** @brief Internal storage of the second color (corrected and altered
      * value).
      *
      * The color is normalized and bound to the LCH color space. In an
      * additional step, it has been altered (by increasing or decreasing the
      * hue component in steps of 360°) to minimize the distance in hue
      * from this color to @ref m_firstColorCorrected. This is necessary to
      * easily allow to calculate the intermediate colors of the gradient, so
      * that they take the shortest way through the color space.
      * @sa @ref setFirstColor()
      * @sa @ref setSecondColor()
      * @sa @ref completlyNormalizedAndBounded()
      * @sa @ref updateSecondColor() */
     LchaDouble m_secondColorCorrectedAndAltered;
 };
 
 } // namespace PerceptualColor
 
 Q_DECLARE_METATYPE(PerceptualColor::GradientImageParameters)
 
 #endif // GRADIENTIMAGEPARAMETERS_H