Changeset 8127 in ntrip for trunk/BNC/qwt/qwt_plot_layout.cpp

Timestamp:

May 10, 2017, 3:20:54 PM (7 years ago)

Author:

stoecker

Message:

update qwt and qwtpolar, many QT5 fixes (unfinished)

File:

• trunk/BNC/qwt/qwt_plot_layout.cpp (modified) (64 diffs)

trunk/BNC/qwt/qwt_plot_layout.cpp

@@ -11 +11 @@
 #include "qwt_text.h"
 #include "qwt_text_label.h"
-#include "qwt_plot_canvas.h"
 #include "qwt_scale_widget.h"
-#include "qwt_legend.h"
+#include "qwt_abstract_legend.h"
 #include <qscrollbar.h>
 #include <qmath.h>
@@ -25 +24 @@
     {
         int frameWidth;
-        int vScrollBarWidth;
-        int hScrollBarHeight;
+        int hScrollExtent;
+        int vScrollExtent;
         QSize hint;
     } legend;
@@ -35 +34 @@
         int frameWidth;
     } title;
+
+    struct t_footerData
+    {
+        QwtText text;
+        int frameWidth;
+    } footer;
 
     struct t_scaleData
@@ -44 +49 @@
         int end;
         int baseLineOffset;
-        int tickOffset;
+        double tickOffset;
         int dimWithoutTitle;
     } scale[QwtPlot::axisCnt];
@@ -50 +55 @@
     struct t_canvasData
     {
-        int frameWidth;
+        int contentsMargins[ QwtPlot::axisCnt ];
+
     } canvas;
 };
@@ -57 +63 @@
   Extract all layout relevant data from the plot components
 */
-
 void QwtPlotLayout::LayoutData::init( const QwtPlot *plot, const QRectF &rect )
 {
     // legend
 
-    if ( plot->plotLayout()->legendPosition() != QwtPlot::ExternalLegend
-        && plot->legend() )
+    if ( plot->legend() )
     {
         legend.frameWidth = plot->legend()->frameWidth();
-        legend.vScrollBarWidth =
-            plot->legend()->verticalScrollBar()->sizeHint().width();
-        legend.hScrollBarHeight =
-            plot->legend()->horizontalScrollBar()->sizeHint().height();
+        legend.hScrollExtent =
+            plot->legend()->scrollExtent( Qt::Horizontal );
+        legend.vScrollExtent =
+            plot->legend()->scrollExtent( Qt::Vertical );
 
         const QSize hint = plot->legend()->sizeHint();
 
-        int w = qMin( hint.width(), qFloor( rect.width() ) );
+        const int w = qMin( hint.width(), qFloor( rect.width() ) );
+
         int h = plot->legend()->heightForWidth( w );
-        if ( h == 0 )
+        if ( h <= 0 )
             h = hint.height();
-
-        if ( h > rect.height() )
-            w += legend.vScrollBarWidth;
 
         legend.hint = QSize( w, h );
@@ -99 +101 @@
     }
 
+    // footer
+
+    footer.frameWidth = 0;
+    footer.text = QwtText();
+
+    if ( plot->footerLabel() )
+    {
+        const QwtTextLabel *label = plot->footerLabel();
+        footer.text = label->text();
+        if ( !( footer.text.testPaintAttribute( QwtText::PaintUsingTextFont ) ) )
+            footer.text.setFont( label->font() );
+
+        footer.frameWidth = plot->footerLabel()->frameWidth();
+    }
+
     // scales
 
@@ -140 +157 @@
             scale[axis].end = 0;
             scale[axis].baseLineOffset = 0;
-            scale[axis].tickOffset = 0;
+            scale[axis].tickOffset = 0.0;
             scale[axis].dimWithoutTitle = 0;
         }
@@ -147 +164 @@
     // canvas
 
-    canvas.frameWidth = plot->canvas()->frameWidth();
+    plot->canvas()->getContentsMargins( 
+        &canvas.contentsMargins[ QwtPlot::yLeft ], 
+        &canvas.contentsMargins[ QwtPlot::xTop ],
+        &canvas.contentsMargins[ QwtPlot::yRight ],
+        &canvas.contentsMargins[ QwtPlot::xBottom ] );
 }
 
@@ -154 +175 @@
 public:
     PrivateData():
-        spacing( 5 ),
-        alignCanvasToScales( false )
+        spacing( 5 )
     {
     }
 
     QRectF titleRect;
+    QRectF footerRect;
     QRectF legendRect;
     QRectF scaleRect[QwtPlot::axisCnt];
@@ -170 +191 @@
     unsigned int spacing;
     unsigned int canvasMargin[QwtPlot::axisCnt];
-    bool alignCanvasToScales;
+    bool alignCanvasToScales[QwtPlot::axisCnt];
 };
 
@@ -183 +204 @@
     setLegendPosition( QwtPlot::BottomLegend );
     setCanvasMargin( 4 );
+    setAlignCanvasToScales( false );
 
     invalidate();
@@ -203 +225 @@
   \sa canvasMargin()
 
-  \warning The margin will have no effect when alignCanvasToScales is true
+  \warning The margin will have no effect when alignCanvasToScale() is true
 */
 
@@ -221 +243 @@
 
 /*!
+    \param axisId Axis index
     \return Margin around the scale tick borders
     \sa setCanvasMargin()
 */
-int QwtPlotLayout::canvasMargin( int axis ) const
-{
-    if ( axis < 0 || axis >= QwtPlot::axisCnt )
+int QwtPlotLayout::canvasMargin( int axisId ) const
+{
+    if ( axisId < 0 || axisId >= QwtPlot::axisCnt )
         return 0;
 
-    return d_data->canvasMargin[axis];
+    return d_data->canvasMargin[axisId];
+}
+
+/*!
+  \brief Set the align-canvas-to-axis-scales flag for all axes
+
+  \param on True/False
+  \sa setAlignCanvasToScale(), alignCanvasToScale()
+*/
+void QwtPlotLayout::setAlignCanvasToScales( bool on )
+{
+    for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
+        d_data->alignCanvasToScales[axis] = on;
 }
 
 /*!
   Change the align-canvas-to-axis-scales setting. The canvas may:
+
   - extend beyond the axis scale ends to maximize its size,
   - align with the axis scale ends to control its size.
 
-  \param alignCanvasToScales New align-canvas-to-axis-scales setting
-
-  \sa setCanvasMargin()
-  \note In this context the term 'scale' means the backbone of a scale.
-  \warning In case of alignCanvasToScales == true canvasMargin will have
-           no effect
-*/
-void QwtPlotLayout::setAlignCanvasToScales( bool alignCanvasToScales )
-{
-    d_data->alignCanvasToScales = alignCanvasToScales;
+  The axisId parameter is somehow confusing as it identifies a border
+  of the plot and not the axes, that are aligned. F.e when QwtPlot::yLeft
+  is set, the left end of the the x-axes ( QwtPlot::xTop, QwtPlot::xBottom )
+  is aligned.
+
+  \param axisId Axis index
+  \param on New align-canvas-to-axis-scales setting
+
+  \sa setCanvasMargin(), alignCanvasToScale(), setAlignCanvasToScales()
+  \warning In case of on == true canvasMargin() will have no effect
+*/
+void QwtPlotLayout::setAlignCanvasToScale( int axisId, bool on )
+{
+    if ( axisId >= 0 && axisId < QwtPlot::axisCnt )
+        d_data->alignCanvasToScales[axisId] = on;
 }
 
@@ -254 +295 @@
   - align with the axis scale ends to control its size.
 
+  \param axisId Axis index
   \return align-canvas-to-axis-scales setting
-  \sa setAlignCanvasToScales, setCanvasMargin()
-  \note In this context the term 'scale' means the backbone of a scale.
-*/
-bool QwtPlotLayout::alignCanvasToScales() const
-{
-    return d_data->alignCanvasToScales;
+  \sa setAlignCanvasToScale(), setAlignCanvasToScale(), setCanvasMargin()
+*/
+bool QwtPlotLayout::alignCanvasToScale( int axisId ) const
+{
+    if ( axisId < 0 || axisId >= QwtPlot::axisCnt )
+        return false;
+
+    return d_data->alignCanvasToScales[ axisId ];
 }
 
@@ -267 +311 @@
   between the plot components.
 
-  \param spacing new spacing
-  \sa setMargin(), spacing()
+  \param spacing New spacing
+  \sa setCanvasMargin(), spacing()
 */
 void QwtPlotLayout::setSpacing( int spacing )
@@ -276 +320 @@
 
 /*!
-  \return spacing
+  \return Spacing
   \sa margin(), setSpacing()
 */
@@ -287 +331 @@
   \brief Specify the position of the legend
   \param pos The legend's position.
-  \param ratio Ratio between legend and the bounding rect
-               of title, canvas and axes. The legend will be shrinked
+  \param ratio Ratio between legend and the bounding rectangle
+               of title, footer, canvas and axes. The legend will be shrunk
                if it would need more space than the given ratio.
                The ratio is limited to ]0.0 .. 1.0]. In case of <= 0.0
@@ -318 +362 @@
             d_data->legendPos = pos;
             break;
-        case QwtPlot::ExternalLegend:
-            d_data->legendRatio = ratio; // meaningless
-            d_data->legendPos = pos;
         default:
             break;
@@ -351 +392 @@
 /*!
   Specify the relative size of the legend in the plot
-  \param ratio Ratio between legend and the bounding rect
-               of title, canvas and axes. The legend will be shrinked
+  \param ratio Ratio between legend and the bounding rectangle
+               of title, footer, canvas and axes. The legend will be shrunk
                if it would need more space than the given ratio.
                The ratio is limited to ]0.0 .. 1.0]. In case of <= 0.0
@@ -373 +414 @@
 
 /*!
+  \brief Set the geometry for the title
+
+  This method is intended to be used from derived layouts
+  overloading activate()
+
+  \sa titleRect(), activate()
+ */
+void QwtPlotLayout::setTitleRect( const QRectF &rect )
+{
+    d_data->titleRect = rect;
+}
+
+/*!
   \return Geometry for the title
   \sa activate(), invalidate()
 */
-
-const QRectF &QwtPlotLayout::titleRect() const
+QRectF QwtPlotLayout::titleRect() const
 {
     return d_data->titleRect;
+}
+
+/*!
+  \brief Set the geometry for the footer
+
+  This method is intended to be used from derived layouts
+  overloading activate()
+
+  \sa footerRect(), activate()
+ */
+void QwtPlotLayout::setFooterRect( const QRectF &rect )
+{
+    d_data->footerRect = rect;
+}
+
+/*!
+  \return Geometry for the footer
+  \sa activate(), invalidate()
+*/
+QRectF QwtPlotLayout::footerRect() const
+{
+    return d_data->footerRect;
+}
+
+/*!
+  \brief Set the geometry for the legend
+
+  This method is intended to be used from derived layouts
+  overloading activate()
+
+  \param rect Rectangle for the legend
+
+  \sa legendRect(), activate()
+ */
+void QwtPlotLayout::setLegendRect( const QRectF &rect )
+{
+    d_data->legendRect = rect;
 }
 
@@ -386 +476 @@
   \sa activate(), invalidate()
 */
-
-const QRectF &QwtPlotLayout::legendRect() const
+QRectF QwtPlotLayout::legendRect() const
 {
     return d_data->legendRect;
+}
+
+/*!
+  \brief Set the geometry for an axis
+
+  This method is intended to be used from derived layouts
+  overloading activate()
+
+  \param axis Axis index
+  \param rect Rectangle for the scale
+
+  \sa scaleRect(), activate()
+ */
+void QwtPlotLayout::setScaleRect( int axis, const QRectF &rect )
+{
+    if ( axis >= 0 && axis < QwtPlot::axisCnt )
+        d_data->scaleRect[axis] = rect;
 }
 
@@ -397 +503 @@
   \sa activate(), invalidate()
 */
-
-const QRectF &QwtPlotLayout::scaleRect( int axis ) const
+QRectF QwtPlotLayout::scaleRect( int axis ) const
 {
     if ( axis < 0 || axis >= QwtPlot::axisCnt )
@@ -409 +514 @@
 
 /*!
+  \brief Set the geometry for the canvas
+
+  This method is intended to be used from derived layouts
+  overloading activate()
+
+  \sa canvasRect(), activate()
+ */
+void QwtPlotLayout::setCanvasRect( const QRectF &rect )
+{
+    d_data->canvasRect = rect;
+}
+
+/*!
   \return Geometry for the canvas
   \sa activate(), invalidate()
 */
-
-const QRectF &QwtPlotLayout::canvasRect() const
+QRectF QwtPlotLayout::canvasRect() const
 {
     return d_data->canvasRect;
@@ -424 +541 @@
 void QwtPlotLayout::invalidate()
 {
-    d_data->titleRect = d_data->legendRect = d_data->canvasRect = QRect();
+    d_data->titleRect = d_data->footerRect
+        = d_data->legendRect = d_data->canvasRect = QRect();
+
     for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
         d_data->scaleRect[axis] = QRect();
@@ -430 +549 @@
 
 /*!
-  \brief Return a minimum size hint
+  \return Minimum size hint
+  \param plot Plot widget
+
   \sa QwtPlot::minimumSizeHint()
 */
@@ -453 +574 @@
     int canvasBorder[QwtPlot::axisCnt];
 
+    int fw;
+    plot->canvas()->getContentsMargins( &fw, NULL, NULL, NULL );
+
     int axis;
     for ( axis = 0; axis < QwtPlot::axisCnt; axis++ )
@@ -467 +591 @@
             sd.tickOffset = scl->margin();
             if ( scl->scaleDraw()->hasComponent( QwtAbstractScaleDraw::Ticks ) )
-                sd.tickOffset += scl->scaleDraw()->maxTickLength();
-        }
-
-        canvasBorder[axis] = plot->canvas()->frameWidth() +
-            d_data->canvasMargin[axis] + 1;
-
+                sd.tickOffset += qCeil( scl->scaleDraw()->maxTickLength() );
+        }
+
+        canvasBorder[axis] = fw + d_data->canvasMargin[axis] + 1;
     }
 
@@ -524 +646 @@
     }
 
-    const QwtPlotCanvas *canvas = plot->canvas();
+    const QWidget *canvas = plot->canvas();
+
+    int left, top, right, bottom;
+    canvas->getContentsMargins( &left, &top, &right, &bottom );
+
     const QSize minCanvasSize = canvas->minimumSize();
 
     int w = scaleData[QwtPlot::yLeft].w + scaleData[QwtPlot::yRight].w;
     int cw = qMax( scaleData[QwtPlot::xBottom].w, scaleData[QwtPlot::xTop].w )
-        + 2 * ( canvas->frameWidth() + 1 );
+        + left + 1 + right + 1;
     w += qMax( cw, minCanvasSize.width() );
 
     int h = scaleData[QwtPlot::xBottom].h + scaleData[QwtPlot::xTop].h;
     int ch = qMax( scaleData[QwtPlot::yLeft].h, scaleData[QwtPlot::yRight].h )
-        + 2 * ( canvas->frameWidth() + 1 );
+        + top + 1 + bottom + 1;
     h += qMax( ch, minCanvasSize.height() );
 
-    const QwtTextLabel *title = plot->titleLabel();
-    if ( title && !title->text().isEmpty() )
-    {
-        // If only QwtPlot::yLeft or QwtPlot::yRight is showing,
-        // we center on the plot canvas.
-        const bool centerOnCanvas = !( plot->axisEnabled( QwtPlot::yLeft )
-            && plot->axisEnabled( QwtPlot::yRight ) );
-
-        int titleW = w;
-        if ( centerOnCanvas )
-        {
-            titleW -= scaleData[QwtPlot::yLeft].w
-                + scaleData[QwtPlot::yRight].w;
-        }
-
-        int titleH = title->heightForWidth( titleW );
-        if ( titleH > titleW ) // Compensate for a long title
-        {
-            w = titleW = titleH;
+    const QwtTextLabel *labels[2];
+    labels[0] = plot->titleLabel();
+    labels[1] = plot->footerLabel();
+
+    for ( int i = 0; i < 2; i++ )
+    {
+        const QwtTextLabel *label   = labels[i];
+        if ( label && !label->text().isEmpty() )
+        {
+            // If only QwtPlot::yLeft or QwtPlot::yRight is showing,
+            // we center on the plot canvas.
+            const bool centerOnCanvas = !( plot->axisEnabled( QwtPlot::yLeft )
+                && plot->axisEnabled( QwtPlot::yRight ) );
+
+            int labelW = w;
             if ( centerOnCanvas )
             {
-                w += scaleData[QwtPlot::yLeft].w
+                labelW -= scaleData[QwtPlot::yLeft].w
                     + scaleData[QwtPlot::yRight].w;
             }
 
-            titleH = title->heightForWidth( titleW );
-        }
-        h += titleH + d_data->spacing;
+            int labelH = label->heightForWidth( labelW );
+            if ( labelH > labelW ) // Compensate for a long title
+            {
+                w = labelW = labelH;
+                if ( centerOnCanvas )
+                {
+                    w += scaleData[QwtPlot::yLeft].w
+                        + scaleData[QwtPlot::yRight].w;
+                }
+
+                labelH = label->heightForWidth( labelW );
+            }
+            h += labelH + d_data->spacing;
+        }
     }
 
     // Compute the legend contribution
 
-    const QwtLegend *legend = plot->legend();
-    if ( d_data->legendPos != QwtPlot::ExternalLegend
-        && legend && !legend->isEmpty() )
+    const QwtAbstractLegend *legend = plot->legend();
+    if ( legend && !legend->isEmpty() )
     {
         if ( d_data->legendPos == QwtPlot::LeftLegend
@@ -583 +715 @@
 
             if ( legendH > h )
-                legendW += legend->verticalScrollBar()->sizeHint().height();
+                legendW += legend->scrollExtent( Qt::Horizontal );
 
             if ( d_data->legendRatio < 1.0 )
@@ -610 +742 @@
 /*!
   Find the geometry for the legend
+
   \param options Options how to layout the legend
   \param rect Rectangle where to place the legend
+
   \return Geometry for the legend
   \sa Options
@@ -637 +771 @@
                 // space for the vertical scrollbar.
 
-                dim += d_data->layoutData.legend.vScrollBarWidth;
+                dim += d_data->layoutData.legend.hScrollExtent;
             }
         }
@@ -644 +778 @@
     {
         dim = qMin( hint.height(), int( rect.height() * d_data->legendRatio ) );
-        dim = qMax( dim, d_data->layoutData.legend.hScrollBarHeight );
+        dim = qMax( dim, d_data->layoutData.legend.vScrollExtent );
     }
 
@@ -664 +798 @@
             legendRect.setHeight( dim );
             break;
-        case QwtPlot::ExternalLegend:
-            break;
     }
 
@@ -673 +805 @@
 /*!
   Align the legend to the canvas
+
   \param canvasRect Geometry of the canvas
   \param legendRect Maximum geometry for the legend
+
   \return Geometry for the aligned legend
 */
@@ -708 +842 @@
 
   \param options Options how to layout the legend
-  \param rect Bounding rect for title, axes and canvas.
+  \param rect Bounding rectangle for title, footer, axes and canvas.
   \param dimTitle Expanded height of the title widget
+  \param dimFooter Expanded height of the footer widget
   \param dimAxis Expanded heights of the axis in axis orientation.
 
   \sa Options
 */
-void QwtPlotLayout::expandLineBreaks( int options, const QRectF &rect,
-    int &dimTitle, int dimAxis[QwtPlot::axisCnt] ) const
-{
-    dimTitle = 0;
+void QwtPlotLayout::expandLineBreaks( Options options, const QRectF &rect,
+    int &dimTitle, int &dimFooter, int dimAxis[QwtPlot::axisCnt] ) const
+{
+    dimTitle = dimFooter = 0;
     for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
         dimAxis[axis] = 0;
@@ -725 +860 @@
     {
         backboneOffset[axis] = 0;
-        if ( !d_data->alignCanvasToScales )
+        if ( !( options & IgnoreFrames ) )
+            backboneOffset[axis] += d_data->layoutData.canvas.contentsMargins[ axis ];
+
+        if ( !d_data->alignCanvasToScales[axis] )
             backboneOffset[axis] += d_data->canvasMargin[axis];
-        if ( !( options & IgnoreFrames ) )
-            backboneOffset[axis] += d_data->layoutData.canvas.frameWidth;
     }
 
@@ -744 +880 @@
         // axis ... . So we loop as long until no size changes.
 
-        if ( !d_data->layoutData.title.text.isEmpty() )
-        {
-            int w = rect.width();
+        if ( !( ( options & IgnoreTitle ) ||
+            d_data->layoutData.title.text.isEmpty() ) )
+        {
+            double w = rect.width();
 
             if ( d_data->layoutData.scale[QwtPlot::yLeft].isEnabled
@@ -766 +903 @@
         }
 
+        if ( !( ( options & IgnoreFooter ) ||
+            d_data->layoutData.footer.text.isEmpty() ) )
+        {
+            double w = rect.width();
+
+            if ( d_data->layoutData.scale[QwtPlot::yLeft].isEnabled
+                != d_data->layoutData.scale[QwtPlot::yRight].isEnabled )
+            {
+                // center to the canvas
+                w -= dimAxis[QwtPlot::yLeft] + dimAxis[QwtPlot::yRight];
+            }
+
+            int d = qCeil( d_data->layoutData.footer.text.heightForWidth( w ) );
+            if ( !( options & IgnoreFrames ) )
+                d += 2 * d_data->layoutData.footer.frameWidth;
+
+            if ( d > dimFooter )
+            {
+                dimFooter = d;
+                done = false;
+            }
+        }
+
         for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
         {
@@ -773 +933 @@
             if ( scaleData.isEnabled )
             {
-                int length;
+                double length;
                 if ( axis == QwtPlot::xTop || axis == QwtPlot::xBottom )
                 {
@@ -804 +964 @@
                         length += qMin(
                             d_data->layoutData.scale[QwtPlot::xBottom].tickOffset,
-                            scaleData.start - backboneOffset[QwtPlot::xBottom] );
+                            double( scaleData.start - backboneOffset[QwtPlot::xBottom] ) );
                     }
                     if ( dimAxis[QwtPlot::xTop] > 0 )
@@ -810 +970 @@
                         length += qMin(
                             d_data->layoutData.scale[QwtPlot::xTop].tickOffset,
-                            scaleData.end - backboneOffset[QwtPlot::xTop] );
+                            double( scaleData.end - backboneOffset[QwtPlot::xTop] ) );
                     }
 
@@ -820 +980 @@
                 if ( !scaleData.scaleWidget->title().isEmpty() )
                 {
-                    d += scaleData.scaleWidget->titleHeightForWidth( length );
+                    d += scaleData.scaleWidget->titleHeightForWidth( qFloor( length ) );
                 }
 
@@ -838 +998 @@
   the empty corners.
 
+  \param options Layout options
+  \param canvasRect Geometry of the canvas ( IN/OUT )
+  \param scaleRect Geometries of the scales ( IN/OUT )
+
   \sa Options
 */
 
-void QwtPlotLayout::alignScales( int options,
+void QwtPlotLayout::alignScales( Options options,
     QRectF &canvasRect, QRectF scaleRect[QwtPlot::axisCnt] ) const
 {
@@ -848 +1012 @@
     {
         backboneOffset[axis] = 0;
-        if ( !d_data->alignCanvasToScales )
+
+        if ( !d_data->alignCanvasToScales[axis] )
+        {
             backboneOffset[axis] += d_data->canvasMargin[axis];
+        }
+
         if ( !( options & IgnoreFrames ) )
-            backboneOffset[axis] += d_data->layoutData.canvas.frameWidth;
+        {
+            backboneOffset[axis] += 
+                d_data->layoutData.canvas.contentsMargins[axis];
+        }
     }
 
@@ -872 +1043 @@
             if ( leftScaleRect.isValid() )
             {
-                const int dx = leftOffset + leftScaleRect.width();
-                if ( d_data->alignCanvasToScales && dx < 0 )
+                const double dx = leftOffset + leftScaleRect.width();
+                if ( d_data->alignCanvasToScales[QwtPlot::yLeft] && dx < 0.0 )
                 {
                     /*
@@ -879 +1050 @@
                       of the left scale.
                      */
-                    canvasRect.setLeft( qMax( canvasRect.left(),
-                        axisRect.left() - dx ) );
+                    const double cLeft = canvasRect.left(); // qreal -> double
+                    canvasRect.setLeft( qMax( cLeft, axisRect.left() - dx ) );
                 }
                 else
@@ -891 +1062 @@
             else
             {
-                if ( d_data->alignCanvasToScales && leftOffset < 0 )
+                if ( d_data->alignCanvasToScales[QwtPlot::yLeft] && leftOffset < 0 )
                 {
                     canvasRect.setLeft( qMax( canvasRect.left(),
@@ -909 +1080 @@
             if ( rightScaleRect.isValid() )
             {
-                const int dx = rightOffset + rightScaleRect.width();
-                if ( d_data->alignCanvasToScales && dx < 0 )
+                const double dx = rightOffset + rightScaleRect.width();
+                if ( d_data->alignCanvasToScales[QwtPlot::yRight] && dx < 0 )
                 {
                     /*
@@ -916 +1087 @@
                       of the right scale.
                      */
-                    canvasRect.setRight( qMin( canvasRect.right(),
-                        axisRect.right() + dx ) );
+                    const double cRight = canvasRect.right(); // qreal -> double
+                    canvasRect.setRight( qMin( cRight, axisRect.right() + dx ) );
                 }   
 
@@ -926 +1097 @@
             else
             {
-                if ( d_data->alignCanvasToScales && rightOffset < 0 )
+                if ( d_data->alignCanvasToScales[QwtPlot::yRight] && rightOffset < 0 )
                 {
                     canvasRect.setRight( qMin( canvasRect.right(),
@@ -946 +1117 @@
             if ( bottomScaleRect.isValid() )
             {
-                const int dy = bottomOffset + bottomScaleRect.height();
-                if ( d_data->alignCanvasToScales && dy < 0 )
+                const double dy = bottomOffset + bottomScaleRect.height();
+                if ( d_data->alignCanvasToScales[QwtPlot::xBottom] && dy < 0 )
                 {
                     /*
@@ -953 +1124 @@
                       of the bottom scale.
                      */
-                    canvasRect.setBottom( qMin( canvasRect.bottom(),
-                        axisRect.bottom() + dy ) );
+                    const double cBottom = canvasRect.bottom(); // qreal -> double
+                    canvasRect.setBottom( qMin( cBottom, axisRect.bottom() + dy ) );
                 }
                 else
@@ -966 +1137 @@
             else
             {
-                if ( d_data->alignCanvasToScales && bottomOffset < 0 )
+                if ( d_data->alignCanvasToScales[QwtPlot::xBottom] && bottomOffset < 0 )
                 {
                     canvasRect.setBottom( qMin( canvasRect.bottom(),
@@ -983 +1154 @@
             if ( topScaleRect.isValid() )
             {
-                const int dy = topOffset + topScaleRect.height();
-                if ( d_data->alignCanvasToScales && dy < 0 )
+                const double dy = topOffset + topScaleRect.height();
+                if ( d_data->alignCanvasToScales[QwtPlot::xTop] && dy < 0 )
                 {
                     /*
@@ -990 +1161 @@
                       of the top scale.
                      */
-                    canvasRect.setTop( qMax( canvasRect.top(),
-                        axisRect.top() - dy ) );
+                    const double cTop = canvasRect.top(); // qreal -> double
+                    canvasRect.setTop( qMax( cTop, axisRect.top() - dy ) );
                 }
                 else
@@ -1003 +1174 @@
             else
             {
-                if ( d_data->alignCanvasToScales && topOffset < 0 )
+                if ( d_data->alignCanvasToScales[QwtPlot::xTop] && topOffset < 0 )
                 {
                     canvasRect.setTop( qMax( canvasRect.top(),
@@ -1017 +1188 @@
     }
 
-    if ( d_data->alignCanvasToScales )
-    {
-        /*
-          The canvas has been aligned to the scale with largest
-          border distances. Now we have to realign the other scale.
-         */
-
-        int fw = 0;
-        if ( !( options & IgnoreFrames ) )
-            fw = d_data->layoutData.canvas.frameWidth;
-
-        for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
-        {
-            if ( !scaleRect[axis].isValid() )
-                continue;
-
-            if ( axis == QwtPlot::xBottom || axis == QwtPlot::xTop )
-            {
-                scaleRect[axis].setLeft( canvasRect.left() + fw
-                    - d_data->layoutData.scale[axis].start );
-                scaleRect[axis].setRight( canvasRect.right() - fw - 1
-                    + d_data->layoutData.scale[axis].end );
-            }   
-            else
-            {
-                scaleRect[axis].setTop( canvasRect.top() + fw
-                    - d_data->layoutData.scale[axis].start );
-                scaleRect[axis].setBottom( canvasRect.bottom() - fw - 1
-                    + d_data->layoutData.scale[axis].end );
-            }
-        }
-
-        if ( scaleRect[QwtPlot::xTop].isValid() )
-            scaleRect[QwtPlot::xTop].setBottom( canvasRect.top() );
-        if ( scaleRect[QwtPlot::xBottom].isValid() )
-            scaleRect[QwtPlot::xBottom].setTop( canvasRect.bottom() );
-        if ( scaleRect[QwtPlot::yLeft].isValid() )
-            scaleRect[QwtPlot::yLeft].setRight( canvasRect.left() );
-        if ( scaleRect[QwtPlot::yRight].isValid() )
-            scaleRect[QwtPlot::yRight].setLeft( canvasRect.right() );
+    /*
+      The canvas has been aligned to the scale with largest
+      border distances. Now we have to realign the other scale.
+     */
+
+
+    for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
+    {
+        QRectF &sRect = scaleRect[axis];
+
+        if ( !sRect.isValid() )
+            continue;
+
+        if ( axis == QwtPlot::xBottom || axis == QwtPlot::xTop )
+        {
+            if ( d_data->alignCanvasToScales[QwtPlot::yLeft] )
+            {
+                double y = canvasRect.left() - d_data->layoutData.scale[axis].start;
+                if ( !( options & IgnoreFrames ) )
+                    y += d_data->layoutData.canvas.contentsMargins[ QwtPlot::yLeft ];
+
+                sRect.setLeft( y );
+            }
+            if ( d_data->alignCanvasToScales[QwtPlot::yRight] )
+            {
+                double y = canvasRect.right() - 1 + d_data->layoutData.scale[axis].end;
+                if ( !( options & IgnoreFrames ) )
+                    y -= d_data->layoutData.canvas.contentsMargins[ QwtPlot::yRight ];
+
+                sRect.setRight( y );
+            }
+
+            if ( d_data->alignCanvasToScales[ axis ] )
+            {
+                if ( axis == QwtPlot::xTop )
+                    sRect.setBottom( canvasRect.top() );
+                else
+                    sRect.setTop( canvasRect.bottom() );
+            }
+        }
+        else
+        {
+            if ( d_data->alignCanvasToScales[QwtPlot::xTop] )
+            {
+                double x = canvasRect.top() - d_data->layoutData.scale[axis].start;
+                if ( !( options & IgnoreFrames ) )
+                    x += d_data->layoutData.canvas.contentsMargins[ QwtPlot::xTop ];
+
+                sRect.setTop( x );
+            }
+            if ( d_data->alignCanvasToScales[QwtPlot::xBottom] )
+            {
+                double x = canvasRect.bottom() - 1 + d_data->layoutData.scale[axis].end;
+                if ( !( options & IgnoreFrames ) )
+                    x -= d_data->layoutData.canvas.contentsMargins[ QwtPlot::xBottom ];
+
+                sRect.setBottom( x );
+            }
+
+            if ( d_data->alignCanvasToScales[ axis ] )
+            {
+                if ( axis == QwtPlot::yLeft )
+                    sRect.setRight( canvasRect.left() );
+                else
+                    sRect.setLeft( canvasRect.right() );
+            }
+        }
     }
 }
@@ -1064 +1262 @@
 
   \param plot Plot to be layout
-  \param plotRect Rect where to place the components
+  \param plotRect Rectangle where to place the components
   \param options Layout options
 
-  \sa invalidate(), titleRect(),
+  \sa invalidate(), titleRect(), footerRect()
       legendRect(), scaleRect(), canvasRect()
 */
@@ -1077 +1275 @@
     QRectF rect( plotRect );  // undistributed rest of the plot rect
 
-    // We extract all layout relevant data from the widgets,
-    // filter them through pfilter and save them to d_data->layoutData.
+    // We extract all layout relevant parameters from the widgets,
+    // and save them to d_data->layoutData.
 
     d_data->layoutData.init( plot, rect );
 
     if ( !( options & IgnoreLegend )
-        && d_data->legendPos != QwtPlot::ExternalLegend
         && plot->legend() && !plot->legend()->isEmpty() )
     {
@@ -1091 +1288 @@
 
         const QRegion region( rect.toRect() );
-        rect = region.subtract( d_data->legendRect.toRect() ).boundingRect();
+        rect = region.subtracted( d_data->legendRect.toRect() ).boundingRect();
 
         switch ( d_data->legendPos )
@@ -1107 +1304 @@
                 rect.setBottom( rect.bottom() - d_data->spacing );
                 break;
-            case QwtPlot::ExternalLegend:
-                break; // suppress compiler warning
         }
     }
@@ -1125 +1320 @@
      |   |   Axis    |   |
      +---+-----------+---+
+     |      Footer       |
+     +---+-----------+---+
     */
 
-    // axes and title include text labels. The height of each
+    // title, footer and axes include text labels. The height of each
     // label depends on its line breaks, that depend on the width
     // for the label. A line break in a horizontal text will reduce
     // the available width for vertical texts and vice versa.
-    // expandLineBreaks finds the height/width for title and axes
+    // expandLineBreaks finds the height/width for title, footer and axes
     // including all line breaks.
 
-    int dimTitle, dimAxes[QwtPlot::axisCnt];
-    expandLineBreaks( options, rect, dimTitle, dimAxes );
+    int dimTitle, dimFooter, dimAxes[QwtPlot::axisCnt];
+    expandLineBreaks( options, rect, dimTitle, dimFooter, dimAxes );
 
     if ( dimTitle > 0 )
     {
-        d_data->titleRect = QRect( rect.x(), rect.y(),
-            rect.width(), dimTitle );
+        d_data->titleRect.setRect(
+            rect.left(), rect.top(), rect.width(), dimTitle );
+
+        rect.setTop( d_data->titleRect.bottom() + d_data->spacing );
 
         if ( d_data->layoutData.scale[QwtPlot::yLeft].isEnabled !=
@@ -1148 +1347 @@
             // the title centered to the canvas
 
-            d_data->titleRect.setX( rect.x() + dimAxes[QwtPlot::yLeft] );
+            d_data->titleRect.setX( rect.left() + dimAxes[QwtPlot::yLeft] );
             d_data->titleRect.setWidth( rect.width()
                 - dimAxes[QwtPlot::yLeft] - dimAxes[QwtPlot::yRight] );
         }
-
-        // subtract title
-        rect.setTop( rect.top() + dimTitle + d_data->spacing );
+    }
+
+    if ( dimFooter > 0 )
+    {
+        d_data->footerRect.setRect(
+            rect.left(), rect.bottom() - dimFooter, rect.width(), dimFooter );
+
+        rect.setBottom( d_data->footerRect.top() - d_data->spacing );
+
+        if ( d_data->layoutData.scale[QwtPlot::yLeft].isEnabled !=
+            d_data->layoutData.scale[QwtPlot::yRight].isEnabled )
+        {
+            // if only one of the y axes is missing we align
+            // the footer centered to the canvas
+
+            d_data->footerRect.setX( rect.left() + dimAxes[QwtPlot::yLeft] );
+            d_data->footerRect.setWidth( rect.width()
+                - dimAxes[QwtPlot::yLeft] - dimAxes[QwtPlot::yRight] );
+        }
     }