00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012 #include <qlabel.h>
00013 #include "qwt_rect.h"
00014 #include "qwt_text.h"
00015 #include "qwt_plot_canvas.h"
00016 #include "qwt_scale.h"
00017 #include "qwt_legend.h"
00018 #include "qwt_plot_layout.h"
00019
00020 class QwtPlotLayoutData
00021 {
00022 friend class QwtPlotLayout;
00023
00024 protected:
00025 QwtPlotLayoutData();
00026 ~QwtPlotLayoutData();
00027
00028 void init(const QwtPlot *, const QRect &rect);
00029
00030 struct t_legendData
00031 {
00032 int frameWidth;
00033 int vScrollBarWidth;
00034 int hScrollBarHeight;
00035 QSize hint;
00036 } legend;
00037
00038 struct t_titleData
00039 {
00040 const QwtText *text;
00041 int frameWidth;
00042 } title;
00043
00044 struct t_scaleData
00045 {
00046 bool isEnabled;
00047 const QwtScale *scale;
00048 QFont scaleFont;
00049 int start;
00050 int end;
00051 int baseLineOffset;
00052 int tickOffset;
00053 int dimWithoutTitle;
00054 } scale[QwtPlot::axisCnt];
00055
00056 struct t_canvasData
00057 {
00058 int frameWidth;
00059 } canvas;
00060 };
00061
00066 QwtPlotLayout::QwtPlotLayout():
00067 d_margin(0),
00068 d_spacing(5),
00069 d_alignCanvasToScales(FALSE)
00070 {
00071 setLegendPosition(QwtPlot::Bottom);
00072 setCanvasMargin(4);
00073 d_layoutData = new QwtPlotLayoutData;
00074
00075 invalidate();
00076 }
00077
00079 QwtPlotLayout::~QwtPlotLayout()
00080 {
00081 delete d_layoutData;
00082 }
00083
00093 void QwtPlotLayout::setMargin(int margin)
00094 {
00095 if ( margin < 0 )
00096 margin = 0;
00097 d_margin = margin;
00098 }
00099
00106 int QwtPlotLayout::margin() const
00107 {
00108 return d_margin;
00109 }
00110
00124 void QwtPlotLayout::setCanvasMargin(int margin, int axis)
00125 {
00126 if ( margin < -1 )
00127 margin = -1;
00128
00129 if ( axis == -1 )
00130 {
00131 for (axis = 0; axis < QwtPlot::axisCnt; axis++)
00132 d_canvasMargin[axis] = margin;
00133 }
00134 else if ( axis >= 0 || axis < QwtPlot::axisCnt )
00135 d_canvasMargin[axis] = margin;
00136 }
00137
00143 int QwtPlotLayout::canvasMargin(int axis) const
00144 {
00145 if ( axis < 0 || axis >= QwtPlot::axisCnt )
00146 return 0;
00147
00148 return d_canvasMargin[axis];
00149 }
00150
00151
00165 void QwtPlotLayout::setAlignCanvasToScales(bool alignCanvasToScales)
00166 {
00167 d_alignCanvasToScales = alignCanvasToScales;
00168 }
00169
00180 bool QwtPlotLayout::alignCanvasToScales() const
00181 {
00182 return d_alignCanvasToScales;
00183 }
00184
00193 void QwtPlotLayout::setSpacing(int spacing)
00194 {
00195 d_spacing = QMAX(0, spacing);
00196 }
00197
00202 int QwtPlotLayout::spacing() const
00203 {
00204 return d_spacing;
00205 }
00206
00221 void QwtPlotLayout::setLegendPosition(QwtPlot::Position pos, double ratio)
00222 {
00223 if ( ratio > 1.0 )
00224 ratio = 1.0;
00225
00226 switch(pos)
00227 {
00228 case QwtPlot::Top:
00229 case QwtPlot::Bottom:
00230 if ( ratio <= 0.0 )
00231 ratio = 0.33;
00232 d_legendRatio = ratio;
00233 d_legendPos = pos;
00234 break;
00235 case QwtPlot::Left:
00236 case QwtPlot::Right:
00237 if ( ratio <= 0.0 )
00238 ratio = 0.5;
00239 d_legendRatio = ratio;
00240 d_legendPos = pos;
00241 break;
00242 default:
00243 break;
00244 }
00245 }
00246
00255 void QwtPlotLayout::setLegendPosition(QwtPlot::Position pos)
00256 {
00257 setLegendPosition(pos, 0.0);
00258 }
00259
00266 QwtPlot::Position QwtPlotLayout::legendPosition() const
00267 {
00268 return d_legendPos;
00269 }
00270
00271 #ifndef QWT_NO_COMPAT
00272
00288 void QwtPlotLayout::setLegendPos(int pos, double ratio)
00289 {
00290 setLegendPosition(QwtPlot::Position(pos), ratio);
00291 }
00292
00300 int QwtPlotLayout::legendPos() const
00301 {
00302 return d_legendPos;
00303 }
00304
00305 #endif // !QWT_NO_COMPAT
00306
00318 void QwtPlotLayout::setLegendRatio(double ratio)
00319 {
00320 setLegendPosition(legendPosition(), ratio);
00321 }
00322
00328 double QwtPlotLayout::legendRatio() const
00329 {
00330 return d_legendRatio;
00331 }
00332
00338 const QRect &QwtPlotLayout::titleRect() const
00339 {
00340 return d_titleRect;
00341 }
00342
00348 const QRect &QwtPlotLayout::legendRect() const
00349 {
00350 return d_legendRect;
00351 }
00352
00359 const QRect &QwtPlotLayout::scaleRect(int axis) const
00360 {
00361 if ( axis < 0 || axis >= QwtPlot::axisCnt )
00362 {
00363 static QRect dummyRect;
00364 return dummyRect;
00365 }
00366 return d_scaleRect[axis];
00367 }
00368
00374 const QRect &QwtPlotLayout::canvasRect() const
00375 {
00376 return d_canvasRect;
00377 }
00378
00383 void QwtPlotLayout::invalidate()
00384 {
00385 d_titleRect = d_legendRect = d_canvasRect = QRect();
00386 for (int axis = 0; axis < QwtPlot::axisCnt; axis++ )
00387 d_scaleRect[axis] = QRect();
00388 }
00389
00395 QSize QwtPlotLayout::minimumSizeHint(const QwtPlot *plot) const
00396 {
00397 class ScaleData
00398 {
00399 public:
00400 ScaleData()
00401 {
00402 w = h = minLeft = minRight = tickOffset = 0;
00403 }
00404
00405 int w;
00406 int h;
00407 int minLeft;
00408 int minRight;
00409 int tickOffset;
00410 } scaleData[QwtPlot::axisCnt];
00411
00412 int canvasBorder[QwtPlot::axisCnt];
00413
00414 int axis;
00415 for ( axis = 0; axis < QwtPlot::axisCnt; axis++ )
00416 {
00417 const QwtScale *scl = plot->axis(axis);
00418 if ( scl )
00419 {
00420 ScaleData &sd = scaleData[axis];
00421
00422 const QSize hint = scl->minimumSizeHint();
00423 sd.w = hint.width();
00424 sd.h = hint.height();
00425 scl->minBorderDist(sd.minLeft, sd.minRight);
00426 sd.tickOffset = scl->baseLineDist() +
00427 scl->scaleDraw()->majTickLength();
00428 }
00429
00430 canvasBorder[axis] = plot->canvas()->frameWidth() +
00431 d_canvasMargin[axis] + 1;
00432
00433 }
00434
00435
00436 for ( axis = 0; axis < QwtPlot::axisCnt; axis++ )
00437 {
00438 ScaleData &sd = scaleData[axis];
00439 if ( sd.w && (axis == QwtPlot::xBottom || axis == QwtPlot::xTop) )
00440 {
00441 if ( (sd.minLeft > canvasBorder[QwtPlot::yLeft])
00442 && scaleData[QwtPlot::yLeft].w )
00443 {
00444 int shiftLeft = sd.minLeft - canvasBorder[QwtPlot::yLeft];
00445 if ( shiftLeft > scaleData[QwtPlot::yLeft].w )
00446 shiftLeft = scaleData[QwtPlot::yLeft].w;
00447
00448 sd.w -= shiftLeft;
00449 }
00450 if ( (sd.minRight > canvasBorder[QwtPlot::yRight])
00451 && scaleData[QwtPlot::yRight].w )
00452 {
00453 int shiftRight = sd.minRight - canvasBorder[QwtPlot::yRight];
00454 if ( shiftRight > scaleData[QwtPlot::yRight].w )
00455 shiftRight = scaleData[QwtPlot::yRight].w;
00456
00457 sd.w -= shiftRight;
00458 }
00459 }
00460
00461 if ( sd.h && (axis == QwtPlot::yLeft || axis == QwtPlot::yRight) )
00462 {
00463 if ( (sd.minLeft > canvasBorder[QwtPlot::xBottom]) &&
00464 scaleData[QwtPlot::xBottom].h )
00465 {
00466 int shiftBottom = sd.minLeft - canvasBorder[QwtPlot::xBottom];
00467 if ( shiftBottom > scaleData[QwtPlot::xBottom].tickOffset )
00468 shiftBottom = scaleData[QwtPlot::xBottom].tickOffset;
00469
00470 sd.h -= shiftBottom;
00471 }
00472 if ( (sd.minLeft > canvasBorder[QwtPlot::xTop]) &&
00473 scaleData[QwtPlot::xTop].h )
00474 {
00475 int shiftTop = sd.minRight - canvasBorder[QwtPlot::xTop];
00476 if ( shiftTop > scaleData[QwtPlot::xTop].tickOffset )
00477 shiftTop = scaleData[QwtPlot::xTop].tickOffset;
00478
00479 sd.h -= shiftTop;
00480 }
00481 }
00482 }
00483
00484 const QwtPlotCanvas *canvas = plot->canvas();
00485
00486 int w = scaleData[QwtPlot::yLeft].w + scaleData[QwtPlot::yRight].w
00487 + QMAX(scaleData[QwtPlot::xBottom].w, scaleData[QwtPlot::xTop].w)
00488 + 2 * (canvas->frameWidth() + 1);
00489 int h = scaleData[QwtPlot::xBottom].h + scaleData[QwtPlot::xTop].h
00490 + QMAX(scaleData[QwtPlot::yLeft].h, scaleData[QwtPlot::yRight].h)
00491 + 2 * (canvas->frameWidth() + 1);
00492
00493 const QLabel *title = plot->titleLabel();
00494 if (title && !title->text().isEmpty())
00495 {
00496
00497
00498 const bool centerOnCanvas = plot->axis(QwtPlot::yLeft) == 0
00499 || plot->axis(QwtPlot::yRight) == 0;
00500
00501 int titleW = w;
00502 if ( centerOnCanvas )
00503 {
00504 titleW -= scaleData[QwtPlot::yLeft].w
00505 + scaleData[QwtPlot::yRight].w;
00506 }
00507
00508 int titleH = title->heightForWidth(titleW);
00509 if ( titleH > titleW )
00510 {
00511 w = titleW = titleH;
00512 if ( centerOnCanvas )
00513 {
00514 w += scaleData[QwtPlot::yLeft].w
00515 + scaleData[QwtPlot::yRight].w;
00516 }
00517
00518 titleH = title->heightForWidth(titleW);
00519 }
00520 h += titleH + d_spacing;
00521 }
00522
00523
00524
00525 const QwtLegend *legend = plot->legend();
00526 if ( legend && !legend->isEmpty() )
00527 {
00528 if ( d_legendPos == QwtPlot::Left || d_legendPos == QwtPlot::Right )
00529 {
00530 int legendW = legend->sizeHint().width();
00531 int legendH = legend->heightForWidth(legendW);
00532
00533 if ( legend->frameWidth() > 0 )
00534 w += d_spacing;
00535
00536 if ( legendH > h )
00537 legendW += legend->verticalScrollBar()->sizeHint().height();
00538
00539 if ( d_legendRatio < 1.0 )
00540 legendW = QMIN(legendW, int(w / (1.0 - d_legendRatio)));
00541
00542 w += legendW;
00543 }
00544 else
00545 {
00546 int legendW = QMIN(legend->sizeHint().width(), w);
00547 int legendH = legend->heightForWidth(legendW);
00548
00549 if ( legend->frameWidth() > 0 )
00550 h += d_spacing;
00551
00552 if ( d_legendRatio < 1.0 )
00553 legendH = QMIN(legendH, int(h / (1.0 - d_legendRatio)));
00554
00555 h += legendH;
00556 }
00557 }
00558
00559 w += 2 * d_margin;
00560 h += 2 * d_margin;
00561
00562 return QSize( w, h );
00563 }
00564
00572 QRect QwtPlotLayout::layoutLegend(int options,
00573 const QRect &rect) const
00574 {
00575 const QSize hint(d_layoutData->legend.hint);
00576
00577 int dim;
00578 if ( d_legendPos == QwtPlot::Left || d_legendPos == QwtPlot::Right )
00579 {
00580
00581
00582
00583 dim = QMIN(hint.width(), int(rect.width() * d_legendRatio));
00584
00585 if ( !(options & IgnoreScrollbars) )
00586 {
00587 if ( hint.height() > rect.height() )
00588 {
00589
00590
00591
00592 dim += d_layoutData->legend.vScrollBarWidth;
00593 }
00594 }
00595 }
00596 else
00597 {
00598 dim = QMIN(hint.height(), int(rect.height() * d_legendRatio));
00599 dim = QMAX(dim, d_layoutData->legend.hScrollBarHeight);
00600 }
00601
00602 QRect legendRect = rect;
00603 switch(d_legendPos)
00604 {
00605 case QwtPlot::Left:
00606 legendRect.setWidth(dim);
00607 break;
00608 case QwtPlot::Right:
00609 legendRect.setX(rect.right() - dim + 1);
00610 legendRect.setWidth(dim);
00611 break;
00612 case QwtPlot::Top:
00613 legendRect.setHeight(dim);
00614 break;
00615 case QwtPlot::Bottom:
00616 legendRect.setY(rect.bottom() - dim + 1);
00617 legendRect.setHeight(dim);
00618 break;
00619 }
00620
00621 return legendRect;
00622 }
00623
00630 QRect QwtPlotLayout::alignLegend(const QRect &canvasRect,
00631 const QRect &legendRect) const
00632 {
00633 QRect alignedRect = legendRect;
00634
00635 if ( d_legendPos == QwtPlot::Bottom || d_legendPos == QwtPlot::Top )
00636 {
00637 if ( d_layoutData->legend.hint.width() < canvasRect.width() )
00638 {
00639 alignedRect.setX(canvasRect.x());
00640 alignedRect.setWidth(canvasRect.width());
00641 }
00642 }
00643 else
00644 {
00645 if ( d_layoutData->legend.hint.height() < canvasRect.height() )
00646 {
00647 alignedRect.setY(canvasRect.y());
00648 alignedRect.setHeight(canvasRect.height());
00649 }
00650 }
00651
00652 return alignedRect;
00653 }
00654
00664 void QwtPlotLayout::expandLineBreaks(int options, const QRect &rect,
00665 int &dimTitle, int dimAxis[QwtPlot::axisCnt]) const
00666 {
00667 dimTitle = 0;
00668 for ( int i = 0; i < QwtPlot::axisCnt; i++ )
00669 dimAxis[i] = 0;
00670
00671 bool done = FALSE;
00672 while (!done)
00673 {
00674 done = TRUE;
00675
00676
00677
00678
00679
00680
00681
00682
00683
00684 if ( d_layoutData->title.text)
00685 {
00686 int w = rect.width();
00687
00688 if ( d_layoutData->scale[QwtPlot::yLeft].isEnabled
00689 != d_layoutData->scale[QwtPlot::yRight].isEnabled )
00690 {
00691
00692 w -= dimAxis[QwtPlot::yLeft] + dimAxis[QwtPlot::yRight];
00693 }
00694
00695 int d = d_layoutData->title.text->heightForWidth(w);
00696 if ( !(options & IgnoreFrames) )
00697 d += 2 * d_layoutData->title.frameWidth;
00698
00699 if ( d > dimTitle )
00700 {
00701 dimTitle = d;
00702 done = FALSE;
00703 }
00704 }
00705
00706 for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
00707 {
00708 int backboneOffset = d_canvasMargin[axis];
00709 if ( !(options & IgnoreFrames) )
00710 backboneOffset += d_layoutData->canvas.frameWidth;
00711
00712 const struct QwtPlotLayoutData::t_scaleData &scaleData =
00713 d_layoutData->scale[axis];
00714
00715 if (scaleData.isEnabled)
00716 {
00717 int length;
00718 if ( axis == QwtPlot::xTop || axis == QwtPlot::xBottom )
00719 {
00720 length = rect.width() - dimAxis[QwtPlot::yLeft]
00721 - dimAxis[QwtPlot::yRight];
00722 length += QMIN(dimAxis[QwtPlot::yLeft],
00723 scaleData.start - backboneOffset);
00724 length += QMIN(dimAxis[QwtPlot::yRight],
00725 scaleData.end - backboneOffset);
00726 }
00727 else
00728 {
00729 length = rect.height() - dimAxis[QwtPlot::xTop]
00730 - dimAxis[QwtPlot::xBottom];
00731
00732 if ( dimAxis[QwtPlot::xBottom] > 0 )
00733 {
00734 length += QMIN(
00735 d_layoutData->scale[QwtPlot::xBottom].tickOffset,
00736 scaleData.start - backboneOffset);
00737 }
00738 if ( dimAxis[QwtPlot::xTop] > 0 )
00739 {
00740 length += QMIN(
00741 d_layoutData->scale[QwtPlot::xTop].tickOffset,
00742 scaleData.end - backboneOffset);
00743 }
00744
00745 if ( dimTitle > 0 )
00746 length -= dimTitle + d_spacing;
00747 }
00748
00749 int d = scaleData.dimWithoutTitle;
00750 if ( !scaleData.scale->title().isEmpty() )
00751 {
00752 d += scaleData.scale->titleHeightForWidth(length);
00753 }
00754
00755 if ( options & AlignScales )
00756 d -= scaleData.baseLineOffset;
00757
00758 if ( d > dimAxis[axis] )
00759 {
00760 dimAxis[axis] = d;
00761 done = FALSE;
00762 }
00763 }
00764 }
00765 }
00766 }
00767
00773 void QwtPlotLayout::alignScales(int options,
00774 QRect &canvasRect, QRect scaleRect[QwtPlot::axisCnt]) const
00775 {
00776 int axis;
00777
00778 int backboneOffset[QwtPlot::axisCnt];
00779 for (axis = 0; axis < QwtPlot::axisCnt; axis++ )
00780 {
00781 backboneOffset[axis] = 0;
00782 if ( !d_alignCanvasToScales )
00783 backboneOffset[axis] += d_canvasMargin[axis];
00784 if ( !(options & IgnoreFrames) )
00785 backboneOffset[axis] += d_layoutData->canvas.frameWidth;
00786 }
00787
00788 for (axis = 0; axis < QwtPlot::axisCnt; axis++ )
00789 {
00790 if ( !scaleRect[axis].isValid() )
00791 continue;
00792
00793 const int startDist = d_layoutData->scale[axis].start;
00794 const int endDist = d_layoutData->scale[axis].end;
00795
00796 QRect &axisRect = scaleRect[axis];
00797
00798 if ( axis == QwtPlot::xTop || axis == QwtPlot::xBottom )
00799 {
00800 const int leftOffset = backboneOffset[QwtPlot::yLeft] - startDist;
00801
00802 if ( scaleRect[QwtPlot::yLeft].isValid() )
00803 {
00804 int minLeft = scaleRect[QwtPlot::yLeft].left();
00805 int left = axisRect.left() + leftOffset;
00806 axisRect.setLeft(QMAX(left, minLeft));
00807 }
00808 else
00809 {
00810 if ( d_alignCanvasToScales )
00811 {
00812 canvasRect.setLeft(QMAX(canvasRect.left(),
00813 axisRect.left() - leftOffset));
00814 }
00815 else
00816 {
00817 if ( leftOffset > 0 )
00818 axisRect.setLeft(axisRect.left() + leftOffset);
00819 }
00820 }
00821
00822 const int rightOffset = backboneOffset[QwtPlot::yRight] - endDist;
00823
00824 if ( scaleRect[QwtPlot::yRight].isValid() )
00825 {
00826 int maxRight = scaleRect[QwtPlot::yRight].right();
00827 int right = axisRect.right() - rightOffset;
00828 axisRect.setRight(QMIN(right, maxRight));
00829 }
00830 else
00831 {
00832 if ( d_alignCanvasToScales )
00833 {
00834 canvasRect.setRight( QMIN(canvasRect.right(),
00835 axisRect.right() + rightOffset) );
00836 }
00837 else
00838 {
00839 if ( rightOffset > 0 )
00840 axisRect.setRight(axisRect.right() - rightOffset);
00841 }
00842 }
00843 }
00844 else
00845 {
00846 const int bottomOffset =
00847 backboneOffset[QwtPlot::xBottom] - startDist;
00848
00849 if ( scaleRect[QwtPlot::xBottom].isValid() )
00850 {
00851 int maxBottom = scaleRect[QwtPlot::xBottom].top() +
00852 d_layoutData->scale[QwtPlot::xBottom].tickOffset;
00853
00854 int bottom = axisRect.bottom() - bottomOffset;
00855 axisRect.setBottom(QMIN(bottom, maxBottom));
00856 }
00857 else
00858 {
00859 if ( d_alignCanvasToScales )
00860 {
00861 canvasRect.setBottom(QMIN(canvasRect.bottom(),
00862 axisRect.bottom() + bottomOffset));
00863 }
00864 else
00865 {
00866 if ( bottomOffset > 0 )
00867 axisRect.setBottom(axisRect.bottom() - bottomOffset);
00868 }
00869 }
00870
00871 const int topOffset = backboneOffset[QwtPlot::xTop] - endDist;
00872
00873 if ( scaleRect[QwtPlot::xTop].isValid() )
00874 {
00875 int minTop = scaleRect[QwtPlot::xTop].bottom() -
00876 d_layoutData->scale[QwtPlot::xTop].tickOffset;
00877
00878 int top = axisRect.top() + topOffset;
00879 axisRect.setTop(QMAX(top, minTop));
00880 }
00881 else
00882 {
00883 if ( d_alignCanvasToScales )
00884 {
00885 canvasRect.setTop(QMAX(canvasRect.top(),
00886 axisRect.top() + - topOffset));
00887 }
00888 else
00889 {
00890 if ( topOffset > 0 )
00891 axisRect.setTop(axisRect.top() + topOffset);
00892 }
00893 }
00894 }
00895 }
00896 }
00897
00910 void QwtPlotLayout::activate(const QwtPlot *plot,
00911 const QRect &plotRect, int options)
00912 {
00913 invalidate();
00914
00915 QRect rect(plotRect);
00916
00917 if ( !(options & IgnoreMargin) )
00918 {
00919
00920
00921 rect.setRect(
00922 rect.x() + d_margin,
00923 rect.y() + d_margin,
00924 rect.width() - 2 * d_margin,
00925 rect.height() - 2 * d_margin
00926 );
00927 }
00928
00929
00930
00931
00932 d_layoutData->init(plot, rect);
00933
00934 if (!(options & IgnoreLegend)
00935 && plot->legend() && !plot->legend()->isEmpty() )
00936 {
00937 d_legendRect = layoutLegend(options, rect);
00938
00939
00940
00941 const QRegion region(rect);
00942 rect = region.subtract(d_legendRect).boundingRect();
00943
00944 if ( d_layoutData->legend.frameWidth &&
00945 !(options & IgnoreFrames ) )
00946 {
00947
00948
00949
00950
00951 switch(d_legendPos)
00952 {
00953 case QwtPlot::Left:
00954 rect.setLeft(rect.left() + d_spacing);
00955 break;
00956 case QwtPlot::Right:
00957 rect.setRight(rect.right() - d_spacing);
00958 break;
00959 case QwtPlot::Top:
00960 rect.setTop(rect.top() + d_spacing);
00961 break;
00962 case QwtPlot::Bottom:
00963 rect.setBottom(rect.bottom() - d_spacing);
00964 break;
00965 }
00966 }
00967 }
00968
00969
00970
00971
00972
00973
00974
00975
00976
00977
00978
00979
00980
00981
00982
00983
00984
00985
00986
00987
00988
00989
00990
00991
00992 int dimTitle, dimAxes[QwtPlot::axisCnt];
00993 expandLineBreaks(options, rect, dimTitle, dimAxes);
00994
00995 if (dimTitle > 0 )
00996 {
00997 d_titleRect = QRect(rect.x(), rect.y(),
00998 rect.width(), dimTitle);
00999
01000 if ( d_layoutData->scale[QwtPlot::yLeft].isEnabled !=
01001 d_layoutData->scale[QwtPlot::yRight].isEnabled )
01002 {
01003
01004
01005
01006 d_titleRect.setX(rect.x() + dimAxes[QwtPlot::yLeft]);
01007 d_titleRect.setWidth(rect.width()
01008 - dimAxes[QwtPlot::yLeft] - dimAxes[QwtPlot::yRight]);
01009 }
01010
01011
01012 rect.setTop(rect.top() + dimTitle + d_spacing);
01013 }
01014
01015 d_canvasRect.setRect(
01016 rect.x() + dimAxes[QwtPlot::yLeft],
01017 rect.y() + dimAxes[QwtPlot::xTop],
01018 rect.width() - dimAxes[QwtPlot::yRight] - dimAxes[QwtPlot::yLeft],
01019 rect.height() - dimAxes[QwtPlot::xBottom] - dimAxes[QwtPlot::xTop]);
01020
01021 for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
01022 {
01023
01024
01025 if ( dimAxes[axis] )
01026 {
01027 int dim = dimAxes[axis];
01028 QRect &scaleRect = d_scaleRect[axis];
01029
01030 scaleRect = d_canvasRect;
01031 switch(axis)
01032 {
01033 case QwtPlot::yLeft:
01034 scaleRect.setX(d_canvasRect.left() - dim);
01035 scaleRect.setWidth(dim);
01036 break;
01037 case QwtPlot::yRight:
01038 scaleRect.setX(d_canvasRect.right() + 1);
01039 scaleRect.setWidth(dim);
01040 break;
01041 case QwtPlot::xBottom:
01042 scaleRect.setY(d_canvasRect.bottom() + 1);
01043 scaleRect.setHeight(dim);
01044 break;
01045 case QwtPlot::xTop:
01046 scaleRect.setY(d_canvasRect.top() - dim);
01047 scaleRect.setHeight(dim);
01048 break;
01049 }
01050 scaleRect = scaleRect.normalize();
01051 }
01052 }
01053
01054
01055
01056
01057
01058
01059
01060
01061
01062
01063
01064
01065
01066
01067
01068
01069
01070
01071
01072
01073
01074 alignScales(options, d_canvasRect, d_scaleRect);
01075
01076 if (!d_legendRect.isEmpty() )
01077 {
01078
01079
01080
01081 d_legendRect = alignLegend(d_canvasRect, d_legendRect);
01082 }
01083 }
01084
01085 QwtPlotLayoutData::QwtPlotLayoutData()
01086 {
01087 title.text = NULL;
01088 }
01089
01090 QwtPlotLayoutData::~QwtPlotLayoutData()
01091 {
01092 delete title.text;
01093 }
01094
01095
01096
01097
01098
01099 void QwtPlotLayoutData::init(const QwtPlot *plot, const QRect &rect)
01100 {
01101
01102
01103 legend.frameWidth = plot->legend()->frameWidth();
01104 legend.vScrollBarWidth =
01105 plot->legend()->verticalScrollBar()->sizeHint().width();
01106 legend.hScrollBarHeight =
01107 plot->legend()->horizontalScrollBar()->sizeHint().height();
01108
01109 const QSize hint = plot->legend()->sizeHint();
01110
01111 int w = QMIN(hint.width(), rect.width());
01112 int h = plot->legend()->heightForWidth(w);
01113 if ( h == 0 )
01114 h = hint.height();
01115
01116 if ( h > rect.height() )
01117 w += legend.vScrollBarWidth;
01118
01119 legend.hint = QSize(w, h);
01120
01121
01122
01123 title.frameWidth = 0;
01124 delete title.text;
01125 title.text = NULL;
01126
01127 if (plot->titleLabel() && !plot->titleLabel()->text().isEmpty())
01128 {
01129 const QLabel *label = plot->titleLabel();
01130 title.text = QwtText::makeText(label->text(), label->textFormat(),
01131 label->alignment(), label->font());
01132 title.frameWidth = plot->titleLabel()->frameWidth();
01133 }
01134
01135
01136
01137 for (int axis = 0; axis < QwtPlot::axisCnt; axis++ )
01138 {
01139 const QwtScale *sd = plot->axis(axis);
01140 if ( sd )
01141 {
01142 scale[axis].isEnabled = TRUE;
01143
01144 scale[axis].scale = sd;
01145
01146 scale[axis].scaleFont = sd->font();
01147
01148 scale[axis].start = sd->startBorderDist();
01149 scale[axis].end = sd->endBorderDist();
01150
01151 scale[axis].baseLineOffset = sd->baseLineDist();
01152 scale[axis].tickOffset = sd->baseLineDist() +
01153 (int)sd->scaleDraw()->majTickLength();
01154
01155 scale[axis].dimWithoutTitle = sd->dimForLength(
01156 QCOORD_MAX, scale[axis].scaleFont);
01157
01158 if ( !sd->title().isEmpty() )
01159 {
01160 scale[axis].dimWithoutTitle -=
01161 sd->titleHeightForWidth(QCOORD_MAX);
01162 }
01163 }
01164 else
01165 {
01166 scale[axis].isEnabled = FALSE;
01167 scale[axis].start = 0;
01168 scale[axis].end = 0;
01169 scale[axis].baseLineOffset = 0;
01170 scale[axis].tickOffset = 0;
01171 scale[axis].dimWithoutTitle = 0;
01172 }
01173 }
01174
01175
01176
01177 canvas.frameWidth = plot->canvas()->frameWidth();
01178 }