CListGraphics.hpp

Go to the documentation of this file.

#ifndef LIBS_GRAPHICSCOMP_CLISTGRAPHICS_HPP_
#define LIBS_GRAPHICSCOMP_CLISTGRAPHICS_HPP_
 
#include "AbstractCompWithFocusGraphics.hpp"
 
#include "core/memOps.hpp"
#include "ui/gui/CColumnList.hpp"
#include "ui/gui/CEnumComponentsGUI.hpp"
#include "ui/shapes/CDrawText.hpp"
 
#include <string>
#include <utility>
 
class CBufferEdit;
class CDataList;
class CIlluminationGraphics;
class CList;
class CRectangleGraphics;
class CScrollGraphics;
class IFilterModel;
class IModelList;
 
class CListGraphics final : public AbstractCompWithFocusGraphics
{
public:
    CListGraphics(CList *listRef, IFilterModel *filter, bool requestMinSizeForTexts);
    ~CListGraphics() override;
 
    bool sizeChanged() override;
    void updateList();
 
    [[nodiscard]] std::shared_ptr<CDataList> getDataCell(uint64_t indRow, uint64_t indCol) const;
    [[nodiscard]] uint64_t getRowSelected() const;
 
    void setRowSelected(uint64_t indRow);
    void setFilter(IFilterModel **filterOpt);
 
private:
    struct SPrvColumnGraphics
    {
        SPrvColumnGraphics() = delete;
 
        explicit SPrvColumnGraphics(CEnumComponentsGUI::EDataType dataTypeList, std::string txtColumn, double sizeX,
                                    double sizeY, bool widthFixed, bool isEditable,
                                    const std::shared_ptr<std::vector<std::shared_ptr<CDrawText>>> &textColumns)
            : m_dataTypeList(dataTypeList), m_txtColumn(std::move(txtColumn)), m_sizeX(sizeX), m_sizeY(sizeY),
              m_widthFixed(widthFixed), m_isEditable(isEditable)
        {
            m_textColumns = textColumns;
        }
 
        SPrvColumnGraphics(const SPrvColumnGraphics &other) = delete;
        SPrvColumnGraphics(const SPrvColumnGraphics &&other) = delete;
 
        ~SPrvColumnGraphics() = default;
 
        SPrvColumnGraphics &operator=(const SPrvColumnGraphics &other) = delete;
        SPrvColumnGraphics &operator=(const SPrvColumnGraphics &&other) = delete;
 
        CEnumComponentsGUI::EDataType m_dataTypeList;
        std::string m_txtColumn;
        double m_sizeX;
        double m_sizeY;
        bool m_widthFixed;
        bool m_isEditable;
 
        double m_calculatedSizeX {0};
 
        std::shared_ptr<std::vector<std::shared_ptr<CDrawText>>> m_textColumns;
    };
 
    struct SPrvCellFocus
    {
        SPrvCellFocus(uint64_t indRowFocus, uint64_t indColFocus)
            : m_indRowFocus(indRowFocus), m_indColFocus(indColFocus)
        {
        }
 
        uint64_t m_indRowFocus;
        uint64_t m_indColFocus;
    };
 
    void beginFocus() override;
    void calculateSizeMin(IGraphics *graphics, const CTheme *theme, CLibraryImages *libraryImage, double *sizeXComp,
                          double *sizeYComp) override;
    void clean() override;
    void distribute(IGraphics *graphics, double sizeXComp, double sizeYComp) override;
    void drawComponent(IGraphics *graphics, const CTheme *theme) override;
    void endFocus() override;
    void handleEvent(CEventGraphics *event, double xOrg, double yOrg) override;
    void nextFrameChildren() override;
    void processKey(CEventGraphics *evtGraphics) override;
    void removeObjectDraw(IGraphics *graphics) override;
    void update(IGraphics *graphics, CLibraryImages *libraryImage) override;
 
    [[nodiscard]] bool hasLongClick() const override;
 
    void prvAdjustDataColumn(uint64_t numRows, IGraphics *graphics) const;
    void prvBeginFocus() const;
    void prvCalculateNextCell();
    [[nodiscard]] double prvCalculateSizeXTotal() const;
    void prvCheckIntegrity() const;
 
    static void prvColumnAdaptedDataRow(const std::shared_ptr<SPrvColumnGraphics> &column, uint64_t indColumn,
                                        const IModelList *model, double heightTxt, IGraphics *graphics);
    void prvColumnsAdaptedData(double heightTxt, IGraphics *graphics) const;
    std::unique_ptr<std::vector<std::shared_ptr<CListGraphics::SPrvColumnGraphics>>>
    prvCreateColumnsGraphics(double heightTxt, IGraphics *graphics) const;
    void prvDistributeColumns(double sizeXToDistribute, uint64_t numColumnDistributed) const;
    void prvDrawRow(const IModelList *model, uint64_t indRowData, double yOrg, double heightTxt, const CTheme *theme,
                    IGraphics *graphics, bool isAnEvenRow) const;
    void prvEndFocus() const;
    [[nodiscard]] uint64_t prvNumColumnsToDistribute() const;
    void prvTestCellEvent(CEventGraphics *event, double xOrg, uint64_t indRow, bool isLongPulsation);
    void prvTestRowsEvent(CEventGraphics *event, double xOrg, double yOrg, uint64_t indFirstRowIntoArea,
                          bool isLongPulsation);
 
    void prvSetDataInList() const;
 
    [[nodiscard]] bool prvIsFocus(uint64_t indRow, uint64_t indCol) const;
 
    [[nodiscard]] bool isEditNum() const override;
 
    CList *m_listRef;
    IFilterModel *m_filterOpt;
 
    bool m_isChanged;
 
    uint64_t m_indRowSelected;
    uint64_t m_numRowsIntoArea;
 
    bool m_requestMinSizeForTexts;
 
    double m_sizeYHeader;
    double m_sizeYCell;
    double m_sizeYAreaData;
    std::unique_ptr<std::vector<std::shared_ptr<SPrvColumnGraphics>>> m_columns;
    CLibraryImages *m_imagesList;
    CRectangleGraphics *m_areaData;
 
    std::optional<SPrvCellFocus> m_cellFocusCadendateOpt;
    std::optional<SPrvCellFocus> m_cellFocusOpt;
    CBufferEdit *m_bufferEdit;
 
    CScrollGraphics *m_scroll;
};
 
#endif /* LIBS_GRAPHICSCOMP_CLISTGRAPHICS_HPP_ */