QtUtil.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include "stdafx.h"
 
namespace DynExp
{
    class DynExpCore;
    class HardwareAdapterBase;
    class QModuleWidget;
}
 
namespace Util
{
    const QLocale& GetDefaultQtLocale();
 
    using TextType = std::string;                   
    using TextRefType = std::string_view;           
    using TextListType = std::vector<TextType>;     
    using TextListIndexType = size_t;               
 
    template <typename ValueType>
    using TextValueListType = std::vector<std::pair<TextType, ValueType>>;
 
    template <typename EnumType>
    auto QtEnumToTextValueList(unsigned short SkipEntriesFront = 0, unsigned short SkipEntriesEnd = 0,
        unsigned short SkipCharsFront = 0, unsigned short SkipCharsEnd = 0)
    {
        Util::TextValueListType<EnumType> List;
        auto QtEnum = QMetaEnum::fromType<EnumType>();
 
        if (static_cast<long>(QtEnum.keyCount()) - SkipEntriesFront - SkipEntriesEnd <= 0)
            throw Util::OutOfRangeException("Qt enum does not contain any entries (after subtraction).");
 
        for (int i = SkipEntriesFront; i < QtEnum.keyCount() - SkipEntriesEnd; ++i)
        {
            std::string ElementTitle(QtEnum.key(i));
            ElementTitle = ElementTitle.substr(SkipCharsFront, ElementTitle.length() - SkipCharsFront - SkipCharsEnd);
 
            List.emplace_back(ElementTitle.c_str(), static_cast<EnumType>(QtEnum.value(i)));
        }
 
        return List;
    }
 
 
    std::vector<QDomNode> GetChildDOMNodes(const QDomElement& Parent, const QString& ChildTagName);
    
    QDomNode GetSingleChildDOMNode(const QDomElement& Parent, const QString& ChildTagName);
 
    QDomElement GetSingleChildDOMElement(const QDomElement& Parent, const QString& ChildTagName);
 
    std::string GetStringFromDOMElement(const QDomElement& Parent, const QString& ChildTagName);
 
    template <typename T>
    T GetTFromDOMElement(const QDomElement& Parent, const QString& ChildTagName)
    {
        return Util::StrToT<T>(GetStringFromDOMElement(Parent, ChildTagName));
    }
 
    template <>
    std::string GetTFromDOMElement(const QDomElement& Parent, const QString& ChildTagName);
 
    QDomAttr GetDOMAttribute(const QDomElement& Element, const QString& AttributeName);
 
    std::string GetStringFromDOMAttribute(const QDomElement& Element, const QString& AttributeName);
 
    template <typename T>
    T GetTFromDOMAttribute(const QDomElement& Element, const QString& AttributeName)
    {
        return Util::StrToT<T>(GetStringFromDOMAttribute(Element, AttributeName));
    }
 
    template <>
    std::string GetTFromDOMAttribute(const QDomElement& Element, const QString& AttributeName);
 
 
    QString PromptOpenFilePath(QWidget* Parent,
        const QString& Title, const QString& DefaultSuffix, const QString& NameFilter, const QString& InitialDirectory = "");
 
    QString PromptSaveFilePath(QWidget* Parent,
        const QString& Title, const QString& DefaultSuffix, const QString& NameFilter, const QString& InitialDirectory = "");
 
    QString PromptSaveFilePathModule(DynExp::QModuleWidget* Parent,
        const QString& Title, const QString& DefaultSuffix, const QString& NameFilter);
 
 
    QImage QImageFromBlobData(BlobDataType&& BlobData, int Width, int Height, int BytesPerLine, QImage::Format Format);
 
    // Calculates histograms from Image for RGB/intensity channels. Each array in ImageRGBHistogramType conatins values
    // assigned to bins given by the element indices. The three arrays contain histograms for RGB channels in this order.
 
    using ImageHistogramType = std::array<unsigned long long, 256>;
 
    using ImageRGBHistogramType = std::tuple<ImageHistogramType, ImageHistogramType, ImageHistogramType>;
 
    ImageHistogramType ComputeIntensityHistogram(const QImage& Image);
 
    ImageRGBHistogramType ComputeRGBHistogram(const QImage& Image);
 
    ImageHistogramType ConvertRGBToIntensityHistogram(const ImageRGBHistogramType& RGBHistogram);
 
    QPolygonF MakeCrossPolygon(QPointF Center, unsigned int ArmLength);
 
    void ActivateWindow(QWidget& Widget);
 
 
    bool SaveToFile(const QString& Filename, std::string_view Text);
 
    std::string ReadFromFile(const QString& Filename);
 
    std::string ReadFromFile(const std::string& Filename);
 
    std::string ReadFromFile(const std::filesystem::path& Filename);
 
    class QWorker : public QObject
    {
        Q_OBJECT
 
        friend class DynExp::DynExpCore;
 
    protected:
        QWorker() = default;
        ~QWorker() = default;
 
    public:
        void MoveToWorkerThread(DynExp::ItemIDType ID);
 
        auto GetOwner() const noexcept { return Owner.lock(); }
 
    private:
        using OwnerPtrType = std::weak_ptr<const DynExp::HardwareAdapterBase>;
 
        static const DynExp::DynExpCore& GetDynExpCore(const DynExp::DynExpCore* DynExpCore = nullptr);
 
        void SetOwner(OwnerPtrType Owner) noexcept { this->Owner = Owner; }
 
        bool HasBeenMovedToWorkerThread = false;    
        OwnerPtrType Owner;                         
    };
 
    class MarkerGraphicsView : public QGraphicsView
    {
        Q_OBJECT
 
        static constexpr double ZoomFactor = 1.6;               
        static constexpr double DeselectedMarkerOpacity = .5;   
        static constexpr double SelectedMarkerOpacity = 1;      
 
    public:
        struct MarkerType
        {
            using IDType = signed long long;
 
            constexpr MarkerType(QGraphicsPolygonItem* Marker, const QPoint& MarkerPos, bool IsUserDeletable = true, IDType ID = -1, const QPointF& ImagePos = {}) noexcept
                : Marker(Marker), MarkerPos(MarkerPos), UserDeletable(IsUserDeletable), ID(ID), ImagePos(ImagePos) {}
 
            constexpr auto GetMarker() noexcept { return Marker; }
            constexpr const auto GetMarker() const noexcept { return Marker; }
            constexpr const auto& GetMarkerPos() const noexcept { return MarkerPos; }
            constexpr bool IsUserDeletable() const noexcept { return UserDeletable; }
            constexpr auto GetID() const noexcept { return ID; }
            constexpr std::string_view GetName() const noexcept { return Name; }
            constexpr const auto& GetImagePos() const noexcept { return ImagePos; }
 
            void SetName(std::string_view NewName);
 
        private:
            QGraphicsPolygonItem* Marker;                       
            QPoint MarkerPos;                                   
            bool UserDeletable;                                 
            IDType ID;                                          
            std::string Name;                                   
            QPointF ImagePos;                                   
        };
 
        MarkerGraphicsView(QWidget* parent);
 
        auto contextMenu() const noexcept { return ContextMenu; }
        bool HaveMarkersChanged() noexcept;     
        const std::vector<MarkerType>& GetMarkers() const noexcept { return Markers; }
        const auto& GetCurrentImagePos() const noexcept { return CurrentImagePos; }
 
        void SetCurrentImagePos(const QPointF& Pos) { CurrentImagePos = Pos; }
 
 
        void AddMarker(const QPoint& MarkerPos, const QColor& Color, bool IsUserDeletable = true, MarkerType::IDType ID = -1, std::string Name = {});
 
        void RemoveMarker(size_t Index, bool OnlyUserDeletableMarkers = false);
 
        void RemoveMarker(const QPoint& MarkerPos, bool OnlyUserDeletableMarkers = false);
 
        void RemoveMarker(std::string_view Name, bool OnlyUserDeletableMarkers = false);
 
        void RemoveMarkers(bool OnlyUserDeletableMarkers);
 
        void setMarkersHidden(bool MarkersHidden);
 
        void RenameMarker(const QPoint& MarkerPos, std::string_view NewName);
 
        void SelectMarker(const QPoint& MarkerPos);
 
        void DeselectMarkers();
 
        void ZoomIn();                      
        void ZoomOut();                     
        void ZoomReset();                   
 
        void EnableActions(bool Enable);
 
    protected:
        virtual void mousePressEvent(QMouseEvent* Event) override;          
        virtual void mouseDoubleClickEvent(QMouseEvent* Event) override;    
        virtual void wheelEvent(QWheelEvent* Event) override;               
 
    private:
        std::vector<MarkerType> Markers;    
        bool MarkersHidden;                 
        bool MarkersChanged;                
        QPointF CurrentImagePos;            
 
        QMenu* ContextMenu;
        QAction* EditMarkersAction;
        QAction* ShowMarkersAction;
        QAction* RemoveMarkersAction;
        QAction* SaveMarkersAction;
 
    signals:
        void mouseClickEvent(QPoint Position);
 
    private slots:
        void OnContextMenuRequested(QPoint Position);   
        void OnShowMarkers(bool Checked);               
        void OnRemoveMarkers(bool);                     
        void OnSaveMarkers(bool);                       
    };
 
    class QSortingListWidget : public QListWidget
    {
        Q_OBJECT
 
    public:
        QSortingListWidget(QWidget* parent = nullptr) : QListWidget(parent) {}
        ~QSortingListWidget() = default;
 
    private:
        virtual void dropEvent(QDropEvent* event) override;
    };
 
    class NumericSortingTableWidgetItem : public QTableWidgetItem
    {
    public:
        NumericSortingTableWidgetItem() {}
        NumericSortingTableWidgetItem(const QString& text) : QTableWidgetItem(text) {}
        NumericSortingTableWidgetItem(const QIcon& icon, const QString& text) : QTableWidgetItem(icon, text) {}
 
        bool operator<(const QTableWidgetItem& Other) const;
 
        virtual QTableWidgetItem* clone() const override;
    };
 
    class NumericOnlyItemDelegate : public QItemDelegate
    {
        Q_OBJECT
 
    public:
        NumericOnlyItemDelegate(QObject* parent = nullptr, double min = std::numeric_limits<double>::lowest(), double max = std::numeric_limits<double>::max(), int precision = -1)
            : QItemDelegate(parent), min(min), max(max), precision(precision) {}
 
        virtual QWidget* createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const override;
 
    private:
        const double min;
        const double max;
        const int precision;
    };
 
    class DigitalOnlyItemDelegate : public NumericOnlyItemDelegate
    {
        Q_OBJECT
 
    public:
        DigitalOnlyItemDelegate(QObject* parent = nullptr) : NumericOnlyItemDelegate(parent, 0, 1, 0) {}
    };
}
 
Q_DECLARE_METATYPE(Util::MarkerGraphicsView::MarkerType::IDType);