10 #include "qwt_plot_layout.h" 
   12 #include "qwt_text_label.h" 
   13 #include "qwt_scale_widget.h" 
   14 #include "qwt_abstract_legend.h" 
   30                     frameWidth = legend->frameWidth();
 
   34                     hint = legend->sizeHint();
 
   40                 const int w = qMin( hint.width(), qwtFloor( rect.width() ) );
 
   42                 int h = legend->heightForWidth( w );
 
   68                     frameWidth = label->frameWidth();
 
   82                 scaleWidget = axisWidget;
 
   83                 scaleFont = axisWidget->font();
 
   88                 baseLineOffset = axisWidget->
margin();
 
   90                 tickOffset = axisWidget->
margin();
 
   94                 dimWithoutTitle = axisWidget->
dimForLength( QWIDGETSIZE_MAX, scaleFont );
 
  121             void init( 
const QWidget* canvas )
 
  123                 const QMargins m = canvas->contentsMargins();
 
  131             int contentsMargins[ QwtAxis::AxisPositions ];
 
  144         bool hasSymmetricYAxes() 
const;
 
  146         inline ScaleData& axisData( QwtAxisId axisId )
 
  148             return m_scaleData[ axisId ];
 
  151         inline const ScaleData& axisData( QwtAxisId axisId )
 const 
  153             return m_scaleData[ axisId ];
 
  156         inline double tickOffset( 
int axisPos )
 const 
  158             return axisData( axisPos ).tickOffset;
 
  161         LegendData legendData;
 
  162         LabelData labelData[ NumLabels ];
 
  163         CanvasData canvasData;
 
  166         ScaleData m_scaleData[ QwtAxis::AxisPositions ];
 
  172     LayoutData::LayoutData( 
const QwtPlot* plot )
 
  174         legendData.init( plot->
legend() );
 
  175         labelData[ Title ].init( plot->
titleLabel() );
 
  178         for ( 
int axisPos = 0; axisPos < QwtAxis::AxisPositions; axisPos++ )
 
  181                 const QwtAxisId axisId( axisPos );
 
  183                 ScaleData& scaleData = axisData( axisId );
 
  188                     scaleData.init( scaleWidget );
 
  197         canvasData.init( plot->
canvas() );
 
  200     bool LayoutData::hasSymmetricYAxes()
 const 
  203         return m_scaleData[ 
YLeft ].isVisible == m_scaleData[ 
YRight ].isVisible;
 
  212         LayoutHintData( 
const QwtPlot* plot );
 
  214         int alignedSize( 
const QwtAxisId ) 
const;
 
  216         inline int yAxesWidth()
 const 
  219             return axesWidth( YLeft ) + axesWidth( YRight );
 
  222         inline int yAxesHeight()
 const 
  225             return qMax( axesHeight( YLeft ), axesHeight( YRight ) );
 
  228         inline int xAxesHeight()
 const 
  231             return axesHeight( XTop ) + axesHeight( XBottom );
 
  234         inline int xAxesWidth()
 const 
  237             return qMax( axesWidth( XTop ), axesWidth( XBottom ) );
 
  246                 w = h = minLeft = minRight = tickOffset = 0;
 
  257         const ScaleData& axisData( QwtAxisId axisId )
 const 
  259             return m_scaleData[ axisId ];
 
  262         ScaleData& axisData( QwtAxisId axisId )
 
  264             return m_scaleData[ axisId ];
 
  267         inline int axesWidth( 
int axisPos )
 const 
  269             return m_scaleData[axisPos].w;
 
  272         inline int axesHeight( 
int axisPos )
 const 
  274             return m_scaleData[axisPos].h;
 
  277         int m_canvasBorder[QwtAxis::AxisPositions];
 
  278         ScaleData m_scaleData[QwtAxis::AxisPositions];
 
  281     LayoutHintData::LayoutHintData( 
const QwtPlot* plot )
 
  285         const QMargins m = plot->
canvas()->contentsMargins();
 
  287         int contentsMargins[ 4 ];
 
  288         contentsMargins[ 
YLeft ] = m.left();
 
  289         contentsMargins[ 
XTop ] = m.top();
 
  290         contentsMargins[ 
YRight ] = m.right();
 
  291         contentsMargins[ 
XBottom ] = m.bottom();
 
  293         for ( 
int axisPos = 0; axisPos < AxisPositions; axisPos++ )
 
  295             m_canvasBorder[axisPos] = contentsMargins[axisPos] +
 
  298                 const QwtAxisId axisId( axisPos );
 
  306                     ScaleData& sd = axisData( axisId );
 
  308                     sd.h = hint.height();
 
  312                         sd.tickOffset = scl->
margin();
 
  320         for ( 
int axis = 0; axis < AxisPositions; axis++ )
 
  322             const int sz = alignedSize( axis );
 
  324             ScaleData& sd = axisData( axis );
 
  332     int LayoutHintData::alignedSize( 
const QwtAxisId axisId )
 const 
  336         const ScaleData& sd = axisData( axisId );
 
  338         if ( sd.w && 
isXAxis( axisId ) )
 
  342             if ( 
const int leftW = axesWidth( YLeft ) )
 
  344                 const int shiftLeft = sd.minLeft - m_canvasBorder[
YLeft];
 
  346                     w -= qMin( shiftLeft, leftW );
 
  349             if ( 
const int rightW = axesWidth( YRight ) )
 
  351                 const int shiftRight = sd.minRight - m_canvasBorder[
YRight];
 
  352                 if ( shiftRight > 0 )
 
  353                     w -= qMin( shiftRight, rightW );
 
  359         if ( sd.h && 
isYAxis( axisId ) )
 
  363             if ( axesHeight( XBottom ) )
 
  365                 const int shiftBottom = sd.minLeft - m_canvasBorder[
XBottom];
 
  366                 if ( shiftBottom > 0 )
 
  367                     h -= qMin( shiftBottom, axisData( XBottom ).tickOffset );
 
  370             if ( axesHeight( XTop ) )
 
  372                 const int shiftTop = sd.minRight - m_canvasBorder[
XTop];
 
  374                     h -= qMin( shiftTop, axisData( XTop ).tickOffset );
 
  393                 dimTitle = dimFooter = 0;
 
  394                 for ( 
int axisPos = 0; axisPos < QwtAxis::AxisPositions; axisPos++ )
 
  395                     m_dimAxes[axisPos] = 0;
 
  398             inline int dimAxis( QwtAxisId axisId )
 const 
  400                 return m_dimAxes[ axisId ];
 
  403             void setDimAxis( QwtAxisId axisId, 
int dim )
 
  405                 m_dimAxes[ axisId ] = dim;
 
  408             inline int dimAxes( 
int axisPos )
 const 
  410                 return m_dimAxes[ axisPos ];
 
  413             inline int dimYAxes()
 const 
  418             inline int dimXAxes()
 const 
  423             inline QRectF centered( 
const QRectF& rect, 
const QRectF& labelRect )
 const 
  425                 QRectF r = labelRect;
 
  427                 r.setWidth( rect.width() - dimYAxes() );
 
  432             inline QRectF innerRect( 
const QRectF& rect )
 const 
  437                     rect.width() - dimYAxes(),
 
  438                     rect.height() - dimXAxes() );
 
  442                     r.setX( rect.center().x() );
 
  445                 if ( r.height() < 0 )
 
  447                     r.setY( rect.center().y() );
 
  458             int m_dimAxes[QwtAxis::AxisPositions];
 
  462             : m_legendPos( 
QwtPlot::BottomLegend )
 
  463             , m_legendRatio( 1.0 )
 
  469             const LayoutData::LegendData&, 
const QRectF&, 
const QSize& ) 
const;
 
  471         QRectF alignLegend( 
const QSize& legendHint,
 
  472             const QRectF& canvasRect, 
const QRectF& legendRect ) 
const;
 
  475             const LayoutData&, QRectF& canvasRect,
 
  476             QRectF scaleRect[QwtAxis::AxisPositions] ) 
const;
 
  479             const LayoutData&, 
const QRectF& ) 
const;
 
  481         inline void setSpacing( 
unsigned int spacing ) { m_spacing = spacing; }
 
  482         inline unsigned int spacing()
 const { 
return m_spacing; }
 
  484         inline void setAlignCanvas( 
int axisPos, 
bool on ) { m_alignCanvas[ axisPos ] = on; }
 
  485         inline bool alignCanvas( 
int axisPos )
 const { 
return m_alignCanvas[ axisPos ]; }
 
  487         inline void setCanvasMargin( 
int axisPos, 
int margin ) { m_canvasMargin[ axisPos ] = margin; }
 
  488         inline int canvasMargin( 
int axisPos )
 const { 
return m_canvasMargin[ axisPos ]; }
 
  493         inline void setLegendRatio( 
double ratio ) { m_legendRatio = ratio; }
 
  494         inline double legendRatio()
 const { 
return m_legendRatio; }
 
  497         int heightForWidth( LayoutData::Label, 
const LayoutData&,
 
  501         double m_legendRatio;
 
  503         unsigned int m_canvasMargin[QwtAxis::AxisPositions];
 
  504         bool m_alignCanvas[QwtAxis::AxisPositions];
 
  506         unsigned int m_spacing;
 
  511     const LayoutData::LegendData& legendData,
 
  512     const QRectF& rect, 
const QSize& legendHint )
 const 
  521         dim = qMin( legendHint.width(), 
int( rect.width() * m_legendRatio ) );
 
  525             if ( legendHint.height() > rect.height() )
 
  530                 dim += legendData.hScrollExtent;
 
  536         dim = qMin( legendHint.height(), 
int( rect.height() * m_legendRatio ) );
 
  537         dim = qMax( dim, legendData.vScrollExtent );
 
  540     QRectF legendRect = rect;
 
  541     switch ( m_legendPos )
 
  545             legendRect.setWidth( dim );
 
  550             legendRect.setX( rect.right() - dim );
 
  551             legendRect.setWidth( dim );
 
  556             legendRect.setHeight( dim );
 
  561             legendRect.setY( rect.bottom() - dim );
 
  562             legendRect.setHeight( dim );
 
  570 QRectF LayoutEngine::alignLegend( 
const QSize& legendHint,
 
  571     const QRectF& canvasRect, 
const QRectF& legendRect )
 const 
  573     QRectF alignedRect = legendRect;
 
  578         if ( legendHint.width() < canvasRect.width() )
 
  580             alignedRect.setX( canvasRect.x() );
 
  581             alignedRect.setWidth( canvasRect.width() );
 
  586         if ( legendHint.height() < canvasRect.height() )
 
  588             alignedRect.setY( canvasRect.y() );
 
  589             alignedRect.setHeight( canvasRect.height() );
 
  596 int LayoutEngine::heightForWidth(
 
  597     LayoutData::Label labelType, 
const LayoutData& layoutData,
 
  599     double width, 
int axesWidth )
 const 
  601     const LayoutData::LabelData& labelData = layoutData.labelData[ labelType ];
 
  603     if ( labelData.text.isEmpty() )
 
  608     if ( !layoutData.hasSymmetricYAxes() )
 
  614     int d = qwtCeil( labelData.text.heightForWidth( w ) );
 
  616         d += 2 * labelData.frameWidth;
 
  622     const LayoutData& layoutData, 
const QRectF& rect )
 const 
  626     Dimensions dimensions;
 
  628     int backboneOffset[AxisPositions];
 
  629     for ( 
int axisPos = 0; axisPos < AxisPositions; axisPos++ )
 
  631         backboneOffset[axisPos] = 0;
 
  633             backboneOffset[axisPos] += layoutData.canvasData.contentsMargins[axisPos];
 
  635         if ( !m_alignCanvas[axisPos] )
 
  636             backboneOffset[axisPos] += m_canvasMargin[axisPos];
 
  654             const int d = heightForWidth(
 
  655                 LayoutData::Title, layoutData, options,
 
  656                 rect.width(), dimensions.dimYAxes() );
 
  658             if ( d > dimensions.dimTitle )
 
  660                 dimensions.dimTitle = d;
 
  667             const int d = heightForWidth(
 
  668                 LayoutData::Footer, layoutData, options,
 
  669                 rect.width(), dimensions.dimYAxes() );
 
  671             if ( d > dimensions.dimFooter )
 
  673                 dimensions.dimFooter = d;
 
  678         for ( 
int axisPos = 0; axisPos < AxisPositions; axisPos++ )
 
  681                 const QwtAxisId axisId( axisPos );
 
  683                 const LayoutData::ScaleData& scaleData = layoutData.axisData( axisId );
 
  685                 if ( scaleData.isVisible )
 
  690                         length = rect.width() - dimensions.dimYAxes();
 
  691                         length -= scaleData.start + scaleData.end;
 
  693                         if ( dimensions.dimAxes( YRight ) > 0 )
 
  696                         length += qMin( dimensions.dimAxes( YLeft ),
 
  697                             scaleData.start - backboneOffset[YLeft] );
 
  699                         length += qMin( dimensions.dimAxes( YRight ),
 
  700                             scaleData.end - backboneOffset[YRight] );
 
  704                         length = rect.height() - dimensions.dimXAxes();
 
  705                         length -= scaleData.start + scaleData.end;
 
  708                         if ( dimensions.dimAxes( XBottom ) <= 0 )
 
  711                         if ( dimensions.dimAxes( XTop ) <= 0 )
 
  719                         if ( dimensions.dimAxes( XBottom ) > 0 )
 
  722                                 layoutData.tickOffset( XBottom ),
 
  723                                 double( scaleData.start - backboneOffset[XBottom] ) );
 
  726                         if ( dimensions.dimAxes( XTop ) > 0 )
 
  729                                 layoutData.tickOffset( XTop ),
 
  730                                 double( scaleData.end - backboneOffset[XTop] ) );
 
  733                         if ( dimensions.dimTitle > 0 )
 
  734                             length -= dimensions.dimTitle + m_spacing;
 
  737                     int d = scaleData.dimWithoutTitle;
 
  738                     if ( !scaleData.scaleWidget->title().isEmpty() )
 
  740                         d += scaleData.scaleWidget->titleHeightForWidth( qwtFloor( length ) );
 
  744                     if ( d > dimensions.dimAxis( axisId ) )
 
  746                         dimensions.setDimAxis( axisId, d );
 
  758     const LayoutData& layoutData, QRectF& canvasRect,
 
  759     QRectF scaleRect[QwtAxis::AxisPositions] )
 const 
  763     int backboneOffset[AxisPositions];
 
  764     for ( 
int axisPos = 0; axisPos < AxisPositions; axisPos++ )
 
  766         backboneOffset[axisPos] = 0;
 
  768         if ( !m_alignCanvas[axisPos] )
 
  770             backboneOffset[axisPos] += m_canvasMargin[axisPos];
 
  775             backboneOffset[axisPos] +=
 
  776                 layoutData.canvasData.contentsMargins[axisPos];
 
  780     for ( 
int axisPos = 0; axisPos < AxisPositions; axisPos++ )
 
  783             QRectF& axisRect = scaleRect[axisPos];
 
  784             if ( !axisRect.isValid() )
 
  787             const QwtAxisId axisId( axisPos );
 
  789             const int startDist = layoutData.axisData( axisId ).start;
 
  790             const int endDist = layoutData.axisData( axisId ).end;
 
  794                 const QRectF& leftScaleRect = scaleRect[
YLeft];
 
  795                 const int leftOffset = backboneOffset[
YLeft] - startDist;
 
  797                 if ( leftScaleRect.isValid() )
 
  799                     const double dx = leftOffset + leftScaleRect.width();
 
  800                     if ( m_alignCanvas[YLeft] && dx < 0.0 )
 
  806                         const double cLeft = canvasRect.left(); 
 
  807                         canvasRect.setLeft( qwtMaxF( cLeft, axisRect.left() - dx ) );
 
  811                         const double minLeft = leftScaleRect.left();
 
  812                         const double left = axisRect.left() + leftOffset;
 
  813                         axisRect.setLeft( qwtMaxF( left, minLeft ) );
 
  818                     if ( m_alignCanvas[YLeft] && leftOffset < 0 )
 
  820                         canvasRect.setLeft( qwtMaxF( canvasRect.left(),
 
  821                             axisRect.left() - leftOffset ) );
 
  825                         if ( leftOffset > 0 )
 
  826                             axisRect.setLeft( axisRect.left() + leftOffset );
 
  830                 const QRectF& rightScaleRect = scaleRect[
YRight];
 
  831                 const int rightOffset = backboneOffset[
YRight] - endDist + 1;
 
  833                 if ( rightScaleRect.isValid() )
 
  835                     const double dx = rightOffset + rightScaleRect.width();
 
  836                     if ( m_alignCanvas[YRight] && dx < 0 )
 
  842                         const double cRight = canvasRect.right(); 
 
  843                         canvasRect.setRight( qwtMinF( cRight, axisRect.right() + dx ) );
 
  846                     const double maxRight = rightScaleRect.right();
 
  847                     const double right = axisRect.right() - rightOffset;
 
  848                     axisRect.setRight( qwtMinF( right, maxRight ) );
 
  852                     if ( m_alignCanvas[YRight] && rightOffset < 0 )
 
  854                         canvasRect.setRight( qwtMinF( canvasRect.right(),
 
  855                             axisRect.right() + rightOffset ) );
 
  859                         if ( rightOffset > 0 )
 
  860                             axisRect.setRight( axisRect.right() - rightOffset );
 
  866                 const QRectF& bottomScaleRect = scaleRect[
XBottom];
 
  867                 const int bottomOffset = backboneOffset[
XBottom] - endDist + 1;
 
  869                 if ( bottomScaleRect.isValid() )
 
  871                     const double dy = bottomOffset + bottomScaleRect.height();
 
  872                     if ( m_alignCanvas[XBottom] && dy < 0 )
 
  878                         const double cBottom = canvasRect.bottom(); 
 
  879                         canvasRect.setBottom( qwtMinF( cBottom, axisRect.bottom() + dy ) );
 
  883                         const double maxBottom = bottomScaleRect.top() +
 
  884                             layoutData.tickOffset( XBottom );
 
  885                         const double bottom = axisRect.bottom() - bottomOffset;
 
  886                         axisRect.setBottom( qwtMinF( bottom, maxBottom ) );
 
  891                     if ( m_alignCanvas[XBottom] && bottomOffset < 0 )
 
  893                         canvasRect.setBottom( qwtMinF( canvasRect.bottom(),
 
  894                             axisRect.bottom() + bottomOffset ) );
 
  898                         if ( bottomOffset > 0 )
 
  899                             axisRect.setBottom( axisRect.bottom() - bottomOffset );
 
  903                 const QRectF& topScaleRect = scaleRect[
XTop];
 
  904                 const int topOffset = backboneOffset[
XTop] - startDist;
 
  906                 if ( topScaleRect.isValid() )
 
  908                     const double dy = topOffset + topScaleRect.height();
 
  909                     if ( m_alignCanvas[XTop] && dy < 0 )
 
  915                         const double cTop = canvasRect.top(); 
 
  916                         canvasRect.setTop( qwtMaxF( cTop, axisRect.top() - dy ) );
 
  920                         const double minTop = topScaleRect.bottom() -
 
  921                             layoutData.tickOffset( XTop );
 
  923                         const double top = axisRect.top() + topOffset;
 
  924                         axisRect.setTop( qwtMaxF( top, minTop ) );
 
  929                     if ( m_alignCanvas[XTop] && topOffset < 0 )
 
  931                         canvasRect.setTop( qwtMaxF( canvasRect.top(),
 
  932                             axisRect.top() - topOffset ) );
 
  937                             axisRect.setTop( axisRect.top() + topOffset );
 
  949     for ( 
int axisPos = 0; axisPos < AxisPositions; axisPos++ )
 
  952             const QwtAxisId axisId( axisPos );
 
  954             QRectF& sRect = scaleRect[axisPos];
 
  955             const LayoutData::ScaleData& axisData = layoutData.axisData( axisId );
 
  957             if ( !sRect.isValid() )
 
  962                 if ( m_alignCanvas[YLeft] )
 
  964                     double y = canvasRect.left() - axisData.start;
 
  966                         y += layoutData.canvasData.contentsMargins[
YLeft];
 
  971                 if ( m_alignCanvas[YRight] )
 
  973                     double y = canvasRect.right() - 1 + axisData.end;
 
  975                         y -= layoutData.canvasData.contentsMargins[
YRight];
 
  980                 if ( m_alignCanvas[axisPos] )
 
  982                     if ( axisPos == XTop )
 
  983                         sRect.setBottom( canvasRect.top() );
 
  985                         sRect.setTop( canvasRect.bottom() );
 
  990                 if ( m_alignCanvas[XTop] )
 
  992                     double x = canvasRect.top() - axisData.start;
 
  994                         x += layoutData.canvasData.contentsMargins[
XTop];
 
  999                 if ( m_alignCanvas[XBottom] )
 
 1001                     double x = canvasRect.bottom() - 1 + axisData.end;
 
 1003                         x -= layoutData.canvasData.contentsMargins[
XBottom];
 
 1005                     sRect.setBottom( x );
 
 1008                 if ( m_alignCanvas[axisPos] )
 
 1010                     if ( axisPos == YLeft )
 
 1011                         sRect.setRight( canvasRect.left() );
 
 1013                         sRect.setLeft( canvasRect.right() );
 
 1020 class QwtPlotLayout::PrivateData
 
 1026     QRectF scaleRects[QwtAxis::AxisPositions];
 
 1029     LayoutEngine engine;
 
 1038     m_data = 
new PrivateData;
 
 1041     setCanvasMargin( 4 );
 
 1042     setAlignCanvasToScales( 
false );
 
 1071     LayoutEngine& engine = m_data->engine;
 
 1073     if ( axisPos == -1 )
 
 1075         for ( axisPos = 0; axisPos < QwtAxis::AxisPositions; axisPos++ )
 
 1076             engine.setCanvasMargin( axisPos, margin );
 
 1080         engine.setCanvasMargin( axisPos, margin );
 
 1094     return m_data->engine.canvasMargin( axisPos );
 
 1105     for ( 
int axisPos = 0; axisPos < QwtAxis::AxisPositions; axisPos++ )
 
 1106         m_data->engine.setAlignCanvas( axisPos, on );
 
 1129         m_data->engine.setAlignCanvas( axisPos, on );
 
 1146     return m_data->engine.alignCanvas( axisPos );
 
 1158     m_data->engine.setSpacing( qMax( 0, spacing ) );
 
 1167     return m_data->engine.spacing();
 
 1188     LayoutEngine& engine = m_data->engine;
 
 1198             engine.setLegendRatio( ratio );
 
 1199             engine.setLegendPos( pos );
 
 1209             engine.setLegendRatio( ratio );
 
 1210             engine.setLegendPos( pos );
 
 1229     setLegendPosition( pos, 0.0 );
 
 1239     return m_data->engine.legendPos();
 
 1253     setLegendPosition( legendPosition(), ratio );
 
 1262     return m_data->engine.legendRatio();
 
 1275     m_data->titleRect = rect;
 
 1284     return m_data->titleRect;
 
 1297     m_data->footerRect = rect;
 
 1306     return m_data->footerRect;
 
 1321     m_data->legendRect = rect;
 
 1330     return m_data->legendRect;
 
 1347         m_data->scaleRects[axisId] = rect;
 
 1358         return m_data->scaleRects[axisId];
 
 1373     m_data->canvasRect = rect;
 
 1382     return m_data->canvasRect;
 
 1391     m_data->titleRect = m_data->footerRect =
 
 1392         m_data->legendRect = m_data->canvasRect = QRectF();
 
 1394     for ( 
int axisPos = 0; axisPos < QwtAxis::AxisPositions; axisPos++ )
 
 1395         m_data->scaleRects[axisPos] = QRect();
 
 1406     LayoutHintData hintData( plot );
 
 1408     const int xAxesWidth = hintData.xAxesWidth();
 
 1409     const int yAxesHeight = hintData.yAxesHeight();
 
 1411     const QWidget* canvas = plot->
canvas();
 
 1413     const QMargins m = canvas->contentsMargins();
 
 1414     const QSize minCanvasSize = canvas->minimumSize();
 
 1416     int w = hintData.yAxesWidth();
 
 1417     int cw = xAxesWidth + m.left() + 1 + m.right() + 1;
 
 1418     w += qMax( cw, minCanvasSize.width() );
 
 1420     int h = hintData.xAxesHeight();
 
 1421     int ch = yAxesHeight + m.top() + 1 + m.bottom() + 1;
 
 1422     h += qMax( ch, minCanvasSize.height() );
 
 1428     for ( 
int i = 0; i < 2; i++ )
 
 1438             if ( centerOnCanvas )
 
 1440                 labelW -= hintData.yAxesWidth();
 
 1444             if ( labelH > labelW ) 
 
 1446                 w = labelW = labelH;
 
 1447                 if ( centerOnCanvas )
 
 1448                     w += hintData.yAxesWidth();
 
 1452             h += labelH + spacing();
 
 1459     if ( legend && !legend->
isEmpty() )
 
 1461         const LayoutEngine& engine = m_data->engine;
 
 1466             int legendW = legend->sizeHint().width();
 
 1467             int legendH = legend->heightForWidth( legendW );
 
 1469             if ( legend->frameWidth() > 0 )
 
 1475             if ( engine.legendRatio() < 1.0 )
 
 1476                 legendW = qMin( legendW, 
int( w / ( 1.0 - engine.legendRatio() ) ) );
 
 1478             w += legendW + spacing();
 
 1482             int legendW = qMin( legend->sizeHint().width(), w );
 
 1483             int legendH = legend->heightForWidth( legendW );
 
 1485             if ( legend->frameWidth() > 0 )
 
 1488             if ( engine.legendRatio() < 1.0 )
 
 1489                 legendH = qMin( legendH, 
int( h / ( 1.0 - engine.legendRatio() ) ) );
 
 1491             h += legendH + spacing();
 
 1495     return QSize( w, h );
 
 1509     const QRectF& plotRect, 
Options options )
 
 1513     QRectF rect( plotRect );  
 
 1518     LayoutData layoutData( plot );
 
 1522     if ( !( options & IgnoreLegend )
 
 1525         legendHint = layoutData.legendData.legendHint( plot->
legend(), rect );
 
 1527         m_data->legendRect = m_data->engine.layoutLegend(
 
 1528             options, layoutData.legendData, rect, legendHint );
 
 1532         const QRegion region( rect.toRect() );
 
 1533         rect = region.subtracted( m_data->legendRect.toRect() ).boundingRect();
 
 1535         switch ( m_data->engine.legendPos() )
 
 1539                 rect.setLeft( rect.left() + spacing() );
 
 1544                 rect.setRight( rect.right() - spacing() );
 
 1549                 rect.setTop( rect.top() + spacing() );
 
 1554                 rect.setBottom( rect.bottom() - spacing() );
 
 1586     const LayoutEngine::Dimensions dimensions =
 
 1587         m_data->engine.layoutDimensions( options, layoutData, rect );
 
 1589     if ( dimensions.dimTitle > 0 )
 
 1591         QRectF& labelRect = m_data->titleRect;
 
 1593         labelRect.setRect( rect.left(), rect.top(), rect.width(), dimensions.dimTitle );
 
 1595         rect.setTop( labelRect.bottom() + spacing() );
 
 1597         if ( !layoutData.hasSymmetricYAxes() )
 
 1602             labelRect = dimensions.centered( rect, labelRect );
 
 1606     if ( dimensions.dimFooter > 0 )
 
 1608         QRectF& labelRect = m_data->footerRect;
 
 1610         labelRect.setRect( rect.left(), rect.bottom() - dimensions.dimFooter,
 
 1611             rect.width(), dimensions.dimFooter );
 
 1613         rect.setBottom( labelRect.top() - spacing() );
 
 1615         if ( !layoutData.hasSymmetricYAxes() )
 
 1620             labelRect = dimensions.centered( rect, labelRect );
 
 1624     m_data->canvasRect = dimensions.innerRect( rect );
 
 1626     for ( 
int axisPos = 0; axisPos < AxisPositions; axisPos++ )
 
 1632             const QwtAxisId axisId( axisPos );
 
 1634             if ( dimensions.dimAxis( axisId ) )
 
 1636                 const int dim = dimensions.dimAxis( axisId );
 
 1638                 const QRectF& canvasRect = m_data->canvasRect;
 
 1640                 QRectF& scaleRect = m_data->scaleRects[axisId];
 
 1641                 scaleRect = canvasRect;
 
 1647                         scaleRect.setX( canvasRect.left() - pos - dim );
 
 1648                         scaleRect.setWidth( dim );
 
 1653                         scaleRect.setX( canvasRect.right() + pos );
 
 1654                         scaleRect.setWidth( dim );
 
 1659                         scaleRect.setY( canvasRect.bottom() + pos );
 
 1660                         scaleRect.setHeight( dim );
 
 1665                         scaleRect.setY( canvasRect.top() - pos - dim );
 
 1666                         scaleRect.setHeight( dim );
 
 1670                 scaleRect = scaleRect.normalized();
 
 1695     m_data->engine.alignScales( options, layoutData,
 
 1696         m_data->canvasRect, m_data->scaleRects );
 
 1698     if ( !m_data->legendRect.isEmpty() )
 
 1703         m_data->legendRect = m_data->engine.alignLegend(
 
 1704             legendHint, m_data->canvasRect, m_data->legendRect );
 
Abstract base class for legend widgets.
virtual int scrollExtent(Qt::Orientation) const
virtual bool isEmpty() const =0
bool hasComponent(ScaleComponent) const
double maxTickLength() const
@ TopLegend
The legend will be above the title.
@ LeftLegend
The legend will be left from the QwtAxis::YLeft axis.
@ RightLegend
The legend will be right from the QwtAxis::YRight axis.
@ BottomLegend
The legend will be below the footer.
QwtTextLabel * footerLabel()
bool isAxisVisible(QwtAxisId) const
QwtPlotLayout * plotLayout()
QwtAbstractLegend * legend()
const QwtScaleWidget * axisWidget(QwtAxisId) const
QwtTextLabel * titleLabel()
void setCanvasMargin(int margin, int axis=-1)
void setLegendPosition(QwtPlot::LegendPosition pos, double ratio)
Specify the position of the legend.
void setAlignCanvasToScales(bool)
Set the align-canvas-to-axis-scales flag for all axes.
QRectF footerRect() const
int canvasMargin(int axisId) const
QRectF legendRect() const
virtual ~QwtPlotLayout()
Destructor.
virtual void invalidate()
QwtPlot::LegendPosition legendPosition() const
bool alignCanvasToScale(int axisId) const
virtual QSize minimumSizeHint(const QwtPlot *) const
void setLegendRect(const QRectF &)
Set the geometry for the legend.
QRectF scaleRect(QwtAxisId) const
void setFooterRect(const QRectF &)
Set the geometry for the footer.
void setTitleRect(const QRectF &)
Set the geometry for the title.
double legendRatio() const
void setLegendRatio(double ratio)
QRectF canvasRect() const
void setCanvasRect(const QRectF &)
Set the geometry for the canvas.
void setScaleRect(QwtAxisId, const QRectF &)
Set the geometry for an axis.
QwtPlotLayout()
Constructor.
@ IgnoreTitle
Ignore the title.
@ IgnoreFooter
Ignore the footer.
@ IgnoreFrames
Ignore all frames.
virtual void activate(const QwtPlot *, const QRectF &plotRect, Options options=Options())
Recalculate the geometry of all components.
void setAlignCanvasToScale(int axisId, bool)
A class representing a text.
@ PaintUsingTextFont
The text has an individual font.
void setFont(const QFont &)
A Widget which displays a QwtText.
virtual int heightForWidth(int) const override
const QwtText & text() const
Return the text.
bool isYAxis(int axisPos)
@ YRight
Y axis right of the canvas.
@ XTop
X axis above the canvas.
@ XBottom
X axis below the canvas.
@ YLeft
Y axis left of the canvas.
bool isValid(int axisPos)
bool isXAxis(int axisPos)