qwt_plot_layout_engine.h

#ifndef QWTPLOTLAYOUTENGINE_H
#define QWTPLOTLAYOUTENGINE_H
#include <QRectF>
#include <QFont>
class QWidget;
// qwt
#include "qwt_global.h"
#include "qwt_axis.h"
#include "qwt_axis_id.h"
#include "qwt_text.h"
#include "qwt_plot.h"
class QwtAbstractLegend;
class QwtTextLabel;
class QwtScaleWidget;
class QWT_EXPORT QwtPlotLayoutEngine
{
public:
    struct Dimensions
    {
        // Constructor
        Dimensions();
 
        // Get the dimension for a specific axis
        int dimAxis(QwtAxisId axisId) const;
 
        // Set the dimension for a specific axis
        void setDimAxis(QwtAxisId axisId, int dim);
 
        // Get the dimension for an axis position (YLeft, YRight, XTop, XBottom)
        int dimAxes(int axisPos) const;
 
        // Get the total width of left and right Y axes
        int dimYAxes() const;
 
        // Get the total height of top and bottom X axes
        int dimXAxes() const;
 
        // Center a label rectangle within available space after accounting for Y axes
        QRectF centered(const QRectF& rect, const QRectF& labelRect) const;
 
        // Calculate inner rectangle after reserving space for all axes
        QRectF innerRect(const QRectF& rect) const;
 
        int dimTitle;
        int dimFooter;
 
    private:
        int m_dimAxes[ QwtAxis::AxisPositions ];
    };
 
    class LayoutData
    {
    public:
        struct LegendData
        {
            // Initialize legend data from a QwtAbstractLegend
            void init(const QwtAbstractLegend* legend);
 
            // Calculate optimal legend size for the given rectangle
            QSize legendHint(const QwtAbstractLegend* legend, const QRectF& rect) const;
 
            int frameWidth;
            int hScrollExtent;
            int vScrollExtent;
            QSize hint;
        };
 
        struct LabelData
        {
            // Initialize label data from a QwtTextLabel
            void init(const QwtTextLabel* label);
 
            QwtText text;
            int frameWidth;
        };
 
        struct ScaleData
        {
            // Initialize scale data from a QwtScaleWidget
            void init(const QwtScaleWidget* axisWidget);
 
            // Reset scale data to default values
            void reset();
 
            bool isVisible;
            const QwtScaleWidget* scaleWidget;
            QFont scaleFont;
            int start;
            int end;
            int baseLineOffset;
            double tickOffset;
            int dimWithoutTitle;
            int edgeMargin;
        };
 
        struct CanvasData
        {
            // Initialize canvas data from a QWidget
            void init(const QWidget* canvas);
 
            int contentsMargins[ QwtAxis::AxisPositions ];
        };
 
        enum Label
        {
            Title,   
            Footer,  
 
            NumLabels  
        };
 
        // Construct LayoutData from a QwtPlot
        LayoutData(const QwtPlot* plot);
 
        // Check if left and right Y axes have the same visibility state
        bool hasSymmetricYAxes() const;
 
        // Get mutable scale data for a specific axis
        ScaleData& axisData(QwtAxisId axisId);
 
        // Get const scale data for a specific axis
        const ScaleData& axisData(QwtAxisId axisId) const;
 
        // Get tick offset for a specific axis position
        double tickOffset(int axisPos) const;
 
        LegendData legendData;
        LabelData labelData[ NumLabels ];
        CanvasData canvasData;
 
    private:
        ScaleData m_scaleData[ QwtAxis::AxisPositions ];
    };
 
public:
    // Constructor
    QwtPlotLayoutEngine();
 
    // Calculate and return the legend rectangle within the available space
    QRectF layoutLegend(int plotLayoutOptions,
                        const LayoutData::LegendData& legendData,
                        const QRectF& rect,
                        const QSize& legendHint) const;
 
    // Align the legend rectangle relative to the canvas
    QRectF alignLegend(const QSize& legendHint, const QRectF& canvasRect, const QRectF& legendRect) const;
 
    // Align scale rectangles with the canvas, adjusting positions for proper layout
    void alignScales(int plotLayoutOptions,
                     const LayoutData& layoutData,
                     QRectF& canvasRect,
                     QRectF scaleRect[ QwtAxis::AxisPositions ]) const;
 
    // Align scale rectangles to canvas boundaries
    void alignScalesToCanvas(int plotLayoutOptions,
                             const LayoutData& layoutData,
                             const QRectF& canvasRect,
                             QRectF scaleRect[ QwtAxis::AxisPositions ]) const;
 
    // Calculate layout dimensions for title, footer, and all axes
    Dimensions layoutDimensions(int plotLayoutOptions, const LayoutData& layoutData, const QRectF& rect) const;
 
    // Set the spacing between plot components
    void setSpacing(unsigned int spacing);
 
    // Get the spacing between plot components
    unsigned int spacing() const;
 
    // Set whether the canvas should align to the scale at a given axis position
    void setAlignCanvas(int axisPos, bool on);
 
    // Check if the canvas is aligned to the scale at a given axis position
    bool alignCanvas(int axisPos) const;
 
    // Set the margin between canvas and scale at a given axis position
    void setCanvasMargin(int axisPos, int margin);
 
    // Get the margin between canvas and scale at a given axis position
    int canvasMargin(int axisPos) const;
 
    // Set the legend position
    void setLegendPos(QwtPlot::LegendPosition pos);
 
    // Get the legend position
    QwtPlot::LegendPosition legendPos() const;
 
    // Set the legend ratio for size calculation
    void setLegendRatio(double ratio);
 
    // Get the legend ratio for size calculation
    double legendRatio() const;
 
private:
    int heightForWidth(LayoutData::Label labelType,
                       const LayoutData& layoutData,
                       int plotLayoutOptions,
                       double width,
                       int axesWidth) const;
 
    QwtPlot::LegendPosition m_legendPos;
    double m_legendRatio;
 
    unsigned int m_canvasMargin[ QwtAxis::AxisPositions ] = { 0, 0, 0, 0 };
    bool m_alignCanvas[ QwtAxis::AxisPositions ];
 
    unsigned int m_spacing;
};
 
#endif  // QWTPLOTLAYOUTENGINE_H