File indexing completed on 2024-04-14 03:53:48

 /*
  *  SPDX-FileCopyrightText: 2020 Arjen Hiemstra <ahiemstra@heimr.nl>
  *
  *  SPDX-License-Identifier: LGPL-2.0-or-later
  */
 
 #pragma once
 
 #include <QQuickItem>
 #include <memory>
 
 #include <QQmlEngine>
 
 class PaintedRectangleItem;
 
 /**
  * @brief Grouped property for rectangle border.
  */
 class BorderGroup : public QObject
 {
     Q_OBJECT
     QML_ELEMENT
     QML_UNCREATABLE("")
     /**
      * @brief This property holds the border's width in pixels.
      *
      * default: ``0``px
      */
     Q_PROPERTY(qreal width READ width WRITE setWidth NOTIFY changed FINAL)
     /**
      * @brief This property holds the border's color.
      *
      * Full RGBA colors are supported.
      *
      * default: ``Qt::black``
      */
     Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY changed FINAL)
 
 public:
     explicit BorderGroup(QObject *parent = nullptr);
 
     qreal width() const;
     void setWidth(qreal newWidth);
 
     QColor color() const;
     void setColor(const QColor &newColor);
 
     Q_SIGNAL void changed();
 
     inline bool isEnabled() const
     {
         return !qFuzzyIsNull(m_width);
     }
 
 private:
     qreal m_width = 0.0;
     QColor m_color = Qt::black;
 };
 
 /**
  * @brief Grouped property for the rectangle's shadow.
  */
 class ShadowGroup : public QObject
 {
     Q_OBJECT
     QML_ELEMENT
     QML_UNCREATABLE("")
     /**
      * @brief This property holds the shadow's approximate size in pixels.
      * @note The actual shadow size can be less than this value due to falloff.
      *
      * default: ``0``px
      */
     Q_PROPERTY(qreal size READ size WRITE setSize NOTIFY changed FINAL)
     /**
      * @brief This property holds the shadow's offset in pixels on the X axis.
      *
      * default: ``0``px
      */
     Q_PROPERTY(qreal xOffset READ xOffset WRITE setXOffset NOTIFY changed FINAL)
     /**
      * @brief This property holds the shadow's offset in pixels on the Y axis.
      *
      * default: ``0``px
      */
     Q_PROPERTY(qreal yOffset READ yOffset WRITE setYOffset NOTIFY changed FINAL)
     /**
      * @brief This property holds the shadow's color.
      *
      * Full RGBA colors are supported.
      *
      * default: ``Qt::black``
      */
     Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY changed FINAL)
 
 public:
     explicit ShadowGroup(QObject *parent = nullptr);
 
     qreal size() const;
     void setSize(qreal newSize);
 
     qreal xOffset() const;
     void setXOffset(qreal newXOffset);
 
     qreal yOffset() const;
     void setYOffset(qreal newYOffset);
 
     QColor color() const;
     void setColor(const QColor &newShadowColor);
 
     Q_SIGNAL void changed();
 
 private:
     qreal m_size = 0.0;
     qreal m_xOffset = 0.0;
     qreal m_yOffset = 0.0;
     QColor m_color = Qt::black;
 };
 
 /**
  * @brief Grouped property for corner radius.
  */
 class CornersGroup : public QObject
 {
     Q_OBJECT
     QML_ELEMENT
     QML_UNCREATABLE("")
     /**
      * @brief This property holds the top-left corner's radius in pixels.
      *
      * Setting this to ``-1`` indicates that the value should be ignored.
      *
      * default: ``-1``px
      */
     Q_PROPERTY(qreal topLeftRadius READ topLeft WRITE setTopLeft NOTIFY changed FINAL)
 
     /**
      * @brief This property holds the top-right corner's radius in pixels.
      *
      * Setting this to ``-1`` indicates that the value should be ignored.
      *
      * default: ``-1``px
      */
     Q_PROPERTY(qreal topRightRadius READ topRight WRITE setTopRight NOTIFY changed FINAL)
 
     /**
      * @brief This property holds the bottom-left corner's radius in pixels.
      *
      * Setting this to ``-1`` indicates that the value should be ignored.
      *
      * default: ``-1``px
      */
     Q_PROPERTY(qreal bottomLeftRadius READ bottomLeft WRITE setBottomLeft NOTIFY changed FINAL)
 
     /**
      * @brief This property holds the bottom-right corner's radius in pixels.
      *
      * Setting this to ``-1`` indicates that the value should be ignored.
      *
      * default: ``-1``px
      */
     Q_PROPERTY(qreal bottomRightRadius READ bottomRight WRITE setBottomRight NOTIFY changed FINAL)
 
 public:
     explicit CornersGroup(QObject *parent = nullptr);
 
     qreal topLeft() const;
     void setTopLeft(qreal newTopLeft);
 
     qreal topRight() const;
     void setTopRight(qreal newTopRight);
 
     qreal bottomLeft() const;
     void setBottomLeft(qreal newBottomLeft);
 
     qreal bottomRight() const;
     void setBottomRight(qreal newBottomRight);
 
     Q_SIGNAL void changed();
 
     QVector4D toVector4D(float all) const;
 
 private:
     float m_topLeft = -1.0;
     float m_topRight = -1.0;
     float m_bottomLeft = -1.0;
     float m_bottomRight = -1.0;
 };
 
 /**
  * @brief A rectangle with a shadow behind it.
  *
  * This item will render a rectangle, with a shadow below it. The rendering is done
  * using distance fields, which provide greatly improved performance. The shadow is
  * rendered outside of the item's bounds, so the item's width and height are the
  * rectangle's width and height.
  *
  * @since 5.69
  * @since 2.12
  */
 class ShadowedRectangle : public QQuickItem
 {
     Q_OBJECT
     QML_ELEMENT
     /**
      * @brief This property holds the radii of the rectangle's corners.
      *
      * This is the amount of rounding to apply to all of the rectangle's
      * corners, in pixels. Each corner can have a different radius.
      *
      * default: ``0``
      *
      * @see corners
      */
     Q_PROPERTY(qreal radius READ radius WRITE setRadius NOTIFY radiusChanged FINAL)
 
     /**
      * @brief This property holds the rectangle's color.
      *
      * Full RGBA colors are supported.
      *
      * default: ``Qt::white``
      */
     Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged FINAL)
 
     /**
      * @brief This property holds the border's grouped property.
      *
      * Example usage:
      * @code
      * Kirigami.ShadowedRectangle {
      *     border.width: 2
      *     border.color: Kirigami.Theme.textColor
      * }
      * @endcode
      * @see BorderGroup
      */
     Q_PROPERTY(BorderGroup *border READ border CONSTANT FINAL)
 
     /**
      * @brief This property holds the shadow's grouped property.
      *
      * Example usage:
      * @code
      * Kirigami.ShadowedRectangle {
      *     shadow.size: 20
      *     shadow.xOffset: 5
      *     shadow.yOffset: 5
      * }
      * @endcode
      *
      * @see ShadowGroup
      */
     Q_PROPERTY(ShadowGroup *shadow READ shadow CONSTANT FINAL)
 
     /**
      * @brief This property holds the corners grouped property
      *
      * Note that the values from this group override \property radius for the
      * corner they affect.
      *
      * Example usage:
      * @code
      * Kirigami.ShadowedRectangle {
      *     corners.topLeftRadius: 4
      *     corners.topRightRadius: 5
      *     corners.bottomLeftRadius: 2
      *     corners.bottomRightRadius: 10
      * @endcode
      *
      * @see CornersGroup
      */
     Q_PROPERTY(CornersGroup *corners READ corners CONSTANT FINAL)
 
     /**
      * @brief This property holds the rectangle's render mode.
      *
      * default: ``RenderType::Auto``
      *
      * @see RenderType
      */
     Q_PROPERTY(RenderType renderType READ renderType WRITE setRenderType NOTIFY renderTypeChanged FINAL)
 
     /**
      * @brief This property tells whether software rendering is being used.
      *
      * default: ``false``
      */
     Q_PROPERTY(bool softwareRendering READ isSoftwareRendering NOTIFY softwareRenderingChanged FINAL)
 
 public:
     ShadowedRectangle(QQuickItem *parent = nullptr);
     ~ShadowedRectangle() override;
 
     /**
      * @brief Available rendering types for ShadowedRectangle.
      */
     enum RenderType {
 
         /**
          * @brief Automatically determine the optimal rendering type.
          *
          * This will use the highest rendering quality possible, falling back to
          * lower quality if the hardware doesn't support it. It will use software
          * rendering if the QtQuick scene graph is set to use software rendering.
          */
         Auto,
 
         /**
          * @brief Use the highest rendering quality possible, even if the hardware might
          * not be able to handle it normally.
          */
         HighQuality,
 
         /**
          * @brief Use the lowest rendering quality, even if the hardware could handle
          * higher quality rendering.
          *
          * This might result in certain effects being omitted, like shadows.
          */
         LowQuality,
 
         /**
          * @brief Always use software rendering for this rectangle.
          *
          * Software rendering is intended as a fallback when the QtQuick scene
          * graph is configured to use software rendering. It will result in
          * a number of missing features, like shadows and multiple corner radii.
          */
         Software
     };
     Q_ENUM(RenderType)
 
     BorderGroup *border() const;
     ShadowGroup *shadow() const;
     CornersGroup *corners() const;
 
     qreal radius() const;
     void setRadius(qreal newRadius);
     Q_SIGNAL void radiusChanged();
 
     QColor color() const;
     void setColor(const QColor &newColor);
     Q_SIGNAL void colorChanged();
 
     RenderType renderType() const;
     void setRenderType(RenderType renderType);
     Q_SIGNAL void renderTypeChanged();
 
     void componentComplete() override;
 
     bool isSoftwareRendering() const;
 
 Q_SIGNALS:
     void softwareRenderingChanged();
 
 protected:
     PaintedRectangleItem *softwareItem() const;
     void itemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &value) override;
     QSGNode *updatePaintNode(QSGNode *node, QQuickItem::UpdatePaintNodeData *data) override;
 
 private:
     void checkSoftwareItem();
     const std::unique_ptr<BorderGroup> m_border;
     const std::unique_ptr<ShadowGroup> m_shadow;
     const std::unique_ptr<CornersGroup> m_corners;
     qreal m_radius = 0.0;
     QColor m_color = Qt::white;
     RenderType m_renderType = RenderType::Auto;
     PaintedRectangleItem *m_softwareItem = nullptr;
 };