CLayoutBoxGraphics.hpp

Go to the documentation of this file.

#ifndef LIBS_GRAPHICSCOMP_CLAYOUTBOXGRAPHICS_HPP_
#define LIBS_GRAPHICSCOMP_CLAYOUTBOXGRAPHICS_HPP_
 
#include "math/structs.hpp"
#include "ui/graphicsComp/AbstractComponentGraphics.hpp"
 
#include <cstdint>
#include <optional>
#include <vector>
 
class AbstractLayout;
 
class CLayoutBoxGraphics : public AbstractComponentGraphics
{
public:
    static CLayoutBoxGraphics *createHorizontalLayout(bool hasDestroyComponents,
                                                      std::optional<AbstractLayout *> layout = std::nullopt);
    static CLayoutBoxGraphics *createVerticalLayout(bool hasDestroyComponents,
                                                    std::optional<AbstractLayout *> layout = std::nullopt);
 
    CLayoutBoxGraphics(const CLayoutBoxGraphics &layoutBoxGraphics) = delete;
    CLayoutBoxGraphics(CLayoutBoxGraphics &&layoutBoxGraphics) = delete;
    ~CLayoutBoxGraphics() override;
 
    CLayoutBoxGraphics &operator=(const CLayoutBoxGraphics &layoutBoxGraphics) = delete;
    CLayoutBoxGraphics &operator=(CLayoutBoxGraphics &&layoutBoxGraphics) = delete;
    bool operator==(const CLayoutBoxGraphics &b) const;
    bool operator!=(const CLayoutBoxGraphics &b) const;
 
    void addEnd(AbstractComponentGraphics *component, bool isExpand, bool isFill, iv::types::padding padding);
    void addStart(AbstractComponentGraphics *component, bool isExpand, bool isFill, iv::types::padding padding);
    bool sizeChanged() override;
    void update(IGraphics *graphics, CLibraryImages *libraryImage) override;
 
private:
    enum class EPrvBoxType
    {
        Horizontal,
        Vertical
    };
 
    struct SPrvComponentLayout
    {
        SPrvComponentLayout()
        {
            m_compRef = nullptr;
            m_isExpand = false;
            m_isFill = false;
            m_padding = 0;
        }
 
        SPrvComponentLayout(const SPrvComponentLayout &other)
        {
            m_compRef = other.m_compRef;
            m_isExpand = other.m_isExpand;
            m_isFill = other.m_isFill;
            m_padding = other.m_padding;
        }
 
        SPrvComponentLayout(SPrvComponentLayout &&other) = delete;
        ~SPrvComponentLayout() = default;
 
        SPrvComponentLayout &operator=(const SPrvComponentLayout &other) = default;
 
        SPrvComponentLayout &operator=(SPrvComponentLayout &&other) = delete;
 
        bool operator==(const SPrvComponentLayout &b) const
        {
            return (m_compRef == b.m_compRef) && (m_isExpand == b.m_isExpand) && (m_isFill == b.m_isFill) &&
                   (m_padding == b.m_padding);
        }
 
        bool operator!=(const SPrvComponentLayout &b) const
        {
            return (m_compRef != b.m_compRef) || (m_isExpand != b.m_isExpand) || (m_isFill != b.m_isFill) ||
                   (m_padding != b.m_padding);
        }
 
        AbstractComponentGraphics *m_compRef;
        bool m_isExpand;
        bool m_isFill;
        iv::types::padding m_padding;
    };
 
    CLayoutBoxGraphics();
 
    //TODO: revisar refactorizacion de los métodos privados para añadir prefijo prv
    void calculatePosGlobal(double xFather, double yFather) override;
    void calculateSizeMin(IGraphics *graphics, const CTheme *theme, CLibraryImages *libraryImage, double *sizeXComp,
                          double *sizeYComp) override;
    void closing() override;
    void distribute(IGraphics *graphics, double sizeXComp, double sizeYComp) override;
    void drawComponent(IGraphics *graphics, const CTheme *theme) override;
    void handleEvent(CEventGraphics *event, double xOrg, double yOrg) override;
    void nextFrameChildren() override;
    void removeObjectDraw(IGraphics *graphics) override;
 
    bool hasLongClick() const override;
 
    static void prvAddComponent(std::vector<SPrvComponentLayout> &components, AbstractComponentGraphics *component,
                                bool isExpand, bool isFill, iv::types::padding padding);
    static void prvCalculateComponent(IGraphics *graphics, const CTheme *theme, CLibraryImages *libraryImage,
                                      std::vector<SPrvComponentLayout> &childrens);
    static void prvCalculatePosGlobalComponent(std::vector<SPrvComponentLayout> &childrens, double xFather,
                                               double yFather);
    static std::vector<iv::math::geometry::Point2d>
    prvCalculateSizeComponents(CLayoutBoxGraphics::EPrvBoxType typeBox,
                               const std::vector<SPrvComponentLayout> &components, double sizeXArea, double sizeYArea);
    static void prvCalculateSizeLayout(CLayoutBoxGraphics::EPrvBoxType typeBox,
                                       const std::vector<SPrvComponentLayout> &childrens, double *sizeXLayout,
                                       double *sizeYLayout);
    static void prvClosingComponent(std::vector<SPrvComponentLayout> &childrens);
    void prvDestroyComponents();
    static void prvDistributeComponent(CLayoutBoxGraphics::EPrvBoxType typeBox,
                                       const std::vector<iv::math::geometry::Point2d> &sizeCells,
                                       std::vector<SPrvComponentLayout> &components, bool isStart, double xOrg,
                                       double yOrg, class IGraphics *graphics);
    static void prvDrawComponents(const std::vector<SPrvComponentLayout> &components, IGraphics *graphics,
                                  const CTheme *theme);
    static void prvGetSizeComp(const SPrvComponentLayout &comp, double *sizeXOpt, double *sizeYOpt);
    static void prvHandleComponent(std::vector<SPrvComponentLayout> childrens, CEventGraphics *event, double xOrg,
                                   double yOrg);
    static void prvMovePoint(CLayoutBoxGraphics::EPrvBoxType typeBox, double dx, double dy, double *xOrg, double *yOrg);
    static void prvNextFrameComponent(std::vector<SPrvComponentLayout> &childrens);
    static uint64_t prvNumSizeToDistribute(std::vector<SPrvComponentLayout> &component);
    static void prvRecalculateCells(CLayoutBoxGraphics::EPrvBoxType typeBox, double sizeX, double sizeY,
                                    std::vector<SPrvComponentLayout> &start,
                                    std::vector<iv::math::geometry::Point2d> &cellsStart,
                                    std::vector<SPrvComponentLayout> &end,
                                    std::vector<iv::math::geometry::Point2d> &cellsEnd);
    static void prvRemoveObjectDraw(std::vector<SPrvComponentLayout> &components, IGraphics *graphics);
    static void prvSizeCells(CLayoutBoxGraphics::EPrvBoxType typeBox, std::vector<SPrvComponentLayout> &components,
                             std::vector<iv::math::geometry::Point2d> &cells, double sizeTotalComponent, double rest);
    [[nodiscard]] static bool prvSizeChangedComponents(const std::vector<SPrvComponentLayout> &components);
    static void prvTotalSizeComponents(CLayoutBoxGraphics::EPrvBoxType typeBox,
                                       const std::vector<iv::math::geometry::Point2d> &cells, double *sizeTotal);
    static void prvUpdateComponent(std::vector<SPrvComponentLayout> &childrens, IGraphics *graphics,
                                   CLibraryImages *libraryImage);
 
    CLayoutBoxGraphics::EPrvBoxType m_boxType;
    bool m_hasDestroyComponents;
    std::optional<AbstractLayout *> m_layoutComponent;
 
    std::vector<SPrvComponentLayout> m_start;
    std::vector<SPrvComponentLayout> m_end;
};
 
#endif /* LIBS_GRAPHICSCOMP_CLAYOUTBOXGRAPHICS_HPP_ */