00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012 #include <qlabel.h>
00013 #include <qpainter.h>
00014 #include <qfocusdata.h>
00015 #include <qevent.h>
00016 #include "qwt_plot.h"
00017 #include "qwt_plot_layout.h"
00018 #include "qwt_plot_dict.h"
00019 #include "qwt_rect.h"
00020 #include "qwt_scale.h"
00021 #include "qwt_scale.h"
00022 #include "qwt_legend.h"
00023 #include "qwt_dyngrid_layout.h"
00024 #include "qwt_plot_canvas.h"
00025 #include "qwt_math.h"
00026 #include "qwt_paint_buffer.h"
00027
00034 QwtPlot::QwtPlot(QWidget *parent, const char *name) :
00035 QFrame(parent, name, Qt::WRepaintNoErase|Qt::WResizeNoErase)
00036 {
00037 initPlot();
00038 }
00039
00040
00047 QwtPlot::QwtPlot(const QString &title, QWidget *parent, const char *name) :
00048 QFrame(parent, name, Qt::WRepaintNoErase|Qt::WResizeNoErase)
00049 {
00050 initPlot(title);
00051 }
00052
00054 QwtPlot::~QwtPlot()
00055 {
00056 delete d_layout;
00057 delete d_curves;
00058 delete d_markers;
00059 delete d_grid;
00060 }
00061
00066 void QwtPlot::initPlot(const QString &title)
00067 {
00068 d_layout = new QwtPlotLayout;
00069
00070 d_curves = new QwtCurveDict;
00071 d_markers = new QwtMarkerDict;
00072
00073 d_autoReplot = FALSE;
00074
00075 d_lblTitle = new QLabel(title, this);
00076 d_lblTitle->setFont(QFont(fontInfo().family(), 14, QFont::Bold));
00077 d_lblTitle->setAlignment(Qt::AlignCenter|Qt::WordBreak|Qt::ExpandTabs);
00078
00079 d_legend = new QwtLegend(this);
00080 d_autoLegend = FALSE;
00081
00082 d_scale[yLeft] = new QwtScale(QwtScale::Left, this, "yLeft");
00083 d_scale[yRight] = new QwtScale(QwtScale::Right, this, "yRight");
00084 d_scale[xTop] = new QwtScale(QwtScale::Top, this, "xTop");
00085 d_scale[xBottom] = new QwtScale(QwtScale::Bottom, this, "xBottom");
00086
00087 initAxes();
00088
00089 d_grid = new QwtPlotGrid(this);
00090 d_grid->setPen(QPen(Qt::black, 0, Qt::DotLine));
00091 d_grid->enableXMin(FALSE);
00092 d_grid->enableYMin(FALSE);
00093 d_grid->setAxis(xBottom, yLeft);
00094
00095 d_canvas = new QwtPlotCanvas(this);
00096 d_canvas->setFrameStyle(QFrame::Panel|QFrame::Sunken);
00097 d_canvas->setLineWidth(2);
00098 d_canvas->setMidLineWidth(0);
00099
00100 #ifndef QWT_NO_COMPAT
00101 connect(d_canvas, SIGNAL(mousePressed(const QMouseEvent &)),
00102 this, SIGNAL(plotMousePressed(const QMouseEvent &)));
00103 connect(d_canvas, SIGNAL(mouseMoved(const QMouseEvent &)),
00104 this, SIGNAL(plotMouseMoved(const QMouseEvent &)));
00105 connect(d_canvas, SIGNAL(mouseReleased(const QMouseEvent &)),
00106 this, SIGNAL(plotMouseReleased(const QMouseEvent &)));
00107 #endif
00108
00109 updateTabOrder();
00110
00111 QSizePolicy sp;
00112 sp.setHorData( QSizePolicy::MinimumExpanding );
00113 sp.setVerData( QSizePolicy::MinimumExpanding );
00114 setSizePolicy(sp);
00115 }
00116
00118 void QwtPlot::initAxes()
00119 {
00120 int axis;
00121
00122 QFont fscl(fontInfo().family(), 10);
00123 QFont fttl(fontInfo().family(), 12, QFont::Bold);
00124
00125 for(axis = 0; axis < axisCnt; axis++)
00126 {
00127 d_scale[axis]->setFont(fscl);
00128 d_scale[axis]->setTitleFont(fttl);
00129 d_scale[axis]->setBaselineDist(2);
00130 }
00131
00132 d_axisEnabled[yLeft] = TRUE;
00133 d_axisEnabled[yRight] = FALSE;
00134 d_axisEnabled[xBottom] = TRUE;
00135 d_axisEnabled[xTop] = FALSE;
00136
00137 for (axis=0; axis < axisCnt; axis++)
00138 {
00139 d_as[axis].adjust(0.0,1000.0,TRUE);
00140 d_scale[axis]->setScaleDiv(d_as[axis].scaleDiv());
00141 }
00142 }
00143
00147 bool QwtPlot::event(QEvent *e)
00148 {
00149 bool ok = QFrame::event(e);
00150 switch(e->type())
00151 {
00152 #if 0
00153 case QEvent::ChildInserted:
00154 case QEvent::ChildRemoved:
00155 #endif
00156 case QEvent::LayoutHint:
00157 updateLayout();
00158 break;
00159 default:;
00160 }
00161 return ok;
00162 }
00163
00168 void QwtPlot::autoRefresh()
00169 {
00170 if (d_autoReplot)
00171 replot();
00172 }
00173
00188 void QwtPlot::setAutoReplot(bool tf)
00189 {
00190 d_autoReplot = tf;
00191 }
00192
00196 bool QwtPlot::autoReplot() const
00197 {
00198 return d_autoReplot;
00199 }
00200
00205 void QwtPlot::setTitle(const QString &t)
00206 {
00207 d_lblTitle->setText(t);
00208 }
00209
00214 QString QwtPlot::title() const
00215 {
00216 return d_lblTitle->text();
00217 }
00218
00219
00224 void QwtPlot::setTitleFont(const QFont &f)
00225 {
00226 d_lblTitle->setFont(f);
00227 }
00228
00232 QFont QwtPlot::titleFont() const
00233 {
00234 return d_lblTitle->font();
00235 }
00236
00240 QwtPlotLayout *QwtPlot::plotLayout()
00241 {
00242 return d_layout;
00243 }
00244
00248 const QwtPlotLayout *QwtPlot::plotLayout() const
00249 {
00250 return d_layout;
00251 }
00252
00256 QLabel *QwtPlot::titleLabel()
00257 {
00258 return d_lblTitle;
00259 }
00260
00264 const QLabel *QwtPlot::titleLabel() const
00265 {
00266 return d_lblTitle;
00267 }
00268
00273 QwtLegend *QwtPlot::legend()
00274 {
00275 return d_legend;
00276 }
00277
00282 const QwtLegend *QwtPlot::legend() const
00283 {
00284 return d_legend;
00285 }
00286
00287
00291 QwtPlotCanvas *QwtPlot::canvas()
00292 {
00293 return d_canvas;
00294 }
00295
00299 const QwtPlotCanvas *QwtPlot::canvas() const
00300 {
00301 return d_canvas;
00302 }
00303
00309 QSize QwtPlot::sizeHint() const
00310 {
00311 int dw = 0;
00312 int dh = 0;
00313 for ( int axis = 0; axis < axisCnt; axis++ )
00314 {
00315 if ( d_axisEnabled[axis] )
00316 {
00317 const int niceDist = 40;
00318 const QwtScale *scale = d_scale[axis];
00319 const int majCnt = scale->scaleDraw()->scaleDiv().majCnt();
00320
00321 if ( axis == yLeft || axis == yRight )
00322 {
00323 int hDiff = (majCnt - 1) * niceDist
00324 - scale->minimumSizeHint().height();
00325 if ( hDiff > dh )
00326 dh = hDiff;
00327 }
00328 else
00329 {
00330 int wDiff = (majCnt - 1) * niceDist
00331 - scale->minimumSizeHint().width();
00332 if ( wDiff > dw )
00333 dw = wDiff;
00334 }
00335 }
00336 }
00337 return minimumSizeHint() + QSize(dw, dh);
00338 }
00339
00343 QSize QwtPlot::minimumSizeHint() const
00344 {
00345 QSize hint = d_layout->minimumSizeHint(this);
00346 hint += QSize(2 * frameWidth(), 2 * frameWidth());
00347
00348 return hint;
00349 }
00350
00352 void QwtPlot::resizeEvent(QResizeEvent *e)
00353 {
00354 QFrame::resizeEvent(e);
00355 updateLayout();
00356 }
00357
00368 void QwtPlot::replot()
00369 {
00370 bool doAutoReplot = autoReplot();
00371 setAutoReplot(FALSE);
00372
00373 updateAxes();
00374
00375 d_canvas->invalidateCache();
00376 d_canvas->repaint(d_canvas->contentsRect(), FALSE);
00377
00378 setAutoReplot(doAutoReplot);
00379 }
00380
00385 void QwtPlot::updateLayout()
00386 {
00387 d_layout->activate(this, contentsRect());
00388
00389
00390
00391
00392 if (!d_lblTitle->text().isEmpty())
00393 {
00394 d_lblTitle->setGeometry(d_layout->titleRect());
00395 if (!d_lblTitle->isVisible())
00396 d_lblTitle->show();
00397 }
00398 else
00399 d_lblTitle->hide();
00400
00401 for (int axis = 0; axis < axisCnt; axis++ )
00402 {
00403 if (d_axisEnabled[axis])
00404 {
00405 d_scale[axis]->setGeometry(d_layout->scaleRect(axis));
00406
00407 if ( axis == xBottom || axis == xTop )
00408 {
00409 QRegion r(d_layout->scaleRect(axis));
00410 if ( d_axisEnabled[yLeft] )
00411 r = r.subtract(QRegion(d_layout->scaleRect(yLeft)));
00412 if ( d_axisEnabled[yRight] )
00413 r = r.subtract(QRegion(d_layout->scaleRect(yRight)));
00414 r.translate(-d_layout->scaleRect(axis).x(),
00415 -d_layout->scaleRect(axis).y());
00416
00417 d_scale[axis]->setMask(r);
00418 }
00419 if (!d_scale[axis]->isVisible())
00420 d_scale[axis]->show();
00421 }
00422 else
00423 d_scale[axis]->hide();
00424 }
00425
00426 if (d_legend->itemCount() > 0)
00427 {
00428 d_legend->setGeometry(d_layout->legendRect());
00429 d_legend->show();
00430 }
00431 else
00432 d_legend->hide();
00433
00434 d_canvas->setGeometry(d_layout->canvasRect());
00435 }
00436
00438 void QwtPlot::updateAxes()
00439 {
00440 int i;
00441 bool resetDone[axisCnt];
00442 for (i = 0; i < axisCnt; i++)
00443 resetDone[i] = FALSE;
00444
00445
00446
00447
00448
00449 QwtPlotCurveIterator itc = curveIterator();
00450 for (const QwtPlotCurve *c = itc.toFirst(); c != 0; c = ++itc )
00451 {
00452 const int xAxis = c->xAxis();
00453 const int yAxis = c->yAxis();
00454
00455 if ( d_as[xAxis].autoScale() || d_as[yAxis].autoScale() )
00456 {
00457 const QwtDoubleRect rect = c->boundingRect();
00458 if ( rect.isValid() )
00459 {
00460 if ( d_as[xAxis].autoScale() )
00461 {
00462 if ( !resetDone[xAxis] )
00463 {
00464 d_as[xAxis].reset();
00465 resetDone[xAxis] = TRUE;
00466 }
00467 d_as[xAxis].adjust(rect.x1(), rect.x2());
00468 }
00469
00470 if ( d_as[yAxis].autoScale() )
00471 {
00472 if ( !resetDone[yAxis] )
00473 {
00474 d_as[yAxis].reset();
00475 resetDone[yAxis] = TRUE;
00476 }
00477 d_as[yAxis].adjust(rect.y1(), rect.y2());
00478 }
00479 }
00480 }
00481 }
00482
00483
00484
00485
00486 for (i = 0; i < axisCnt; i++)
00487 {
00488 d_scale[i]->setScaleDiv(d_as[i].scaleDiv());
00489
00490 int startDist, endDist;
00491 d_scale[i]->minBorderDist(startDist, endDist);
00492 d_scale[i]->setBorderDist(startDist, endDist);
00493 }
00494
00495 d_grid->setXDiv(d_as[d_grid->xAxis()].scaleDiv());
00496 d_grid->setYDiv(d_as[d_grid->yAxis()].scaleDiv());
00497 }
00498
00500
00501 void QwtPlot::updateTabOrder()
00502 {
00503
00504
00505
00506
00507
00508
00509 if ( d_canvas->focusPolicy() == QWidget::NoFocus || focusData() == NULL )
00510 return;
00511
00512
00513
00514 for ( int i = 0; i < focusData()->count(); i++ )
00515 {
00516 if ( focusData()->next() == d_canvas )
00517 break;
00518 }
00519
00520 const bool canvasFirst = d_layout->legendPosition() == QwtPlot::Bottom ||
00521 d_layout->legendPosition() == QwtPlot::Right;
00522
00523 for ( int j = 0; j < focusData()->count(); j++ )
00524 {
00525 QWidget *w = canvasFirst ? focusData()->next() : focusData()->prev();
00526
00527 if ( w->focusPolicy() != QWidget::NoFocus
00528 && w->parent() && w->parent() == d_legend->contentsWidget() )
00529 {
00530 if ( canvasFirst )
00531 {
00532 do
00533 {
00534 w = focusData()->prev();
00535 } while ( w->focusPolicy() == QWidget::NoFocus );
00536 }
00537
00538 if ( w != d_canvas )
00539 setTabOrder(w, d_canvas);
00540 break;
00541 }
00542 }
00543 }
00544
00546
00547
00548 void QwtPlot::drawContents( QPainter * )
00549 {
00550
00551
00552 QRegion cr( contentsRect() );
00553 cr = cr.subtract( childrenRegion() );
00554 erase( cr );
00555 }
00556
00567 void QwtPlot::drawCanvas(QPainter *painter)
00568 {
00569 QwtArray<QwtDiMap> map(axisCnt);
00570 for ( int axis = 0; axis < axisCnt; axis++ )
00571 map[axis] = canvasMap(axis);
00572
00573 drawCanvasItems(painter,
00574 d_canvas->contentsRect(), map, QwtPlotPrintFilter());
00575 }
00576
00585 void QwtPlot::drawCanvasItems(QPainter *painter, const QRect &rect,
00586 const QwtArray<QwtDiMap> &map, const QwtPlotPrintFilter &pfilter) const
00587 {
00588
00589
00590
00591 if ( pfilter.options() & QwtPlotPrintFilter::PrintGrid )
00592 {
00593 if ( d_grid->enabled() )
00594 {
00595 d_grid->draw(painter, rect,
00596 map[d_grid->xAxis()], map[d_grid->yAxis()]);
00597 }
00598 }
00599
00600
00601
00602
00603 QwtPlotCurveIterator itc = curveIterator();
00604 for (QwtPlotCurve *curve = itc.toFirst(); curve != 0; curve = ++itc )
00605 {
00606 if ( curve->enabled() )
00607 {
00608 curve->draw(painter,
00609 map[curve->xAxis()], map[curve->yAxis()]);
00610 }
00611 }
00612
00613
00614
00615
00616 QwtPlotMarkerIterator itm = markerIterator();
00617 for (QwtPlotMarker *marker = itm.toFirst(); marker != 0; marker = ++itm )
00618 {
00619 if ( marker->enabled() )
00620 {
00621 marker->draw(painter,
00622 map[marker->xAxis()].transform(marker->xValue()),
00623 map[marker->yAxis()].transform(marker->yValue()),
00624 rect);
00625 }
00626 }
00627 }
00628
00641 void QwtPlot::drawCurve(long key, int from, int to)
00642 {
00643 QwtPlotCurve *curve = d_curves->find(key);
00644 if ( !curve )
00645 return;
00646
00647 QPainter p(canvas());
00648
00649 p.setClipping(TRUE);
00650 p.setClipRect(canvas()->contentsRect());
00651
00652 curve->draw(&p,
00653 canvasMap(curve->xAxis()), canvasMap(curve->yAxis()),
00654 from, to);
00655
00656 if ( canvas()->cacheMode() && canvas()->cache())
00657 {
00658 QPainter cachePainter(canvas()->cache());
00659 cachePainter.translate(-canvas()->contentsRect().x(),
00660 -canvas()->contentsRect().y());
00661
00662 curve->draw(&cachePainter,
00663 canvasMap(curve->xAxis()), canvasMap(curve->yAxis()),
00664 from, to);
00665 }
00666 }
00667
00675 QwtDiMap QwtPlot::canvasMap(int axis) const
00676 {
00677 QwtDiMap map;
00678 if ( !d_canvas )
00679 return map;
00680
00681 const QwtScaleDiv &sd = d_as[axis].scaleDiv();
00682 map.setDblRange(sd.lBound(), sd.hBound(), sd.logScale());
00683
00684 if ( axisEnabled(axis) )
00685 {
00686 const QwtScale *s = d_scale[axis];
00687 if ( axis == yLeft || axis == yRight )
00688 {
00689 int y = s->y() + s->startBorderDist() - d_canvas->y();
00690 int h = s->height() - s->startBorderDist() - s->endBorderDist();
00691 map.setIntRange(y + h - 1, y);
00692 }
00693 else
00694 {
00695 int x = s->x() + s->startBorderDist() - d_canvas->x();
00696 int w = s->width() - s->startBorderDist() - s->endBorderDist();
00697 map.setIntRange(x, x + w - 1);
00698 }
00699 }
00700 else
00701 {
00702 const int margin = plotLayout()->canvasMargin(axis);
00703
00704 const QRect &canvasRect = d_canvas->contentsRect();
00705 if ( axis == yLeft || axis == yRight )
00706 {
00707 map.setIntRange(canvasRect.bottom() - margin,
00708 canvasRect.top() + margin);
00709 }
00710 else
00711 {
00712 map.setIntRange(canvasRect.left() + margin,
00713 canvasRect.right() - margin);
00714 }
00715 }
00716 return map;
00717 }
00718
00726 void QwtPlot::setMargin(int margin)
00727 {
00728 if ( margin < 0 )
00729 margin = 0;
00730
00731 if ( margin != d_layout->margin() )
00732 {
00733 d_layout->setMargin(margin);
00734 updateLayout();
00735 }
00736 }
00737
00742 int QwtPlot::margin() const
00743 {
00744 return d_layout->margin();
00745 }
00746
00755 void QwtPlot::setCanvasBackground(const QColor &c)
00756 {
00757 QPalette p = d_canvas->palette();
00758
00759 for ( int i = 0; i < QPalette::NColorGroups; i++ )
00760 p.setColor((QPalette::ColorGroup)i, QColorGroup::Background, c);
00761
00762 canvas()->setPalette(p);
00763 }
00764
00771 const QColor & QwtPlot::canvasBackground() const
00772 {
00773 return canvas()->palette().color(
00774 QPalette::Normal, QColorGroup::Background);
00775 }
00776
00783 void QwtPlot::setCanvasLineWidth(int w)
00784 {
00785 canvas()->setLineWidth(w);
00786 }
00787
00793 int QwtPlot::canvasLineWidth() const
00794 {
00795 return canvas()->lineWidth();
00796 }
00797
00798 #ifndef QWT_NO_COMPAT
00799
00814 void QwtPlot::enableOutline(bool tf)
00815 {
00816 d_canvas->enableOutline(tf);
00817 }
00818
00852 void QwtPlot::setOutlineStyle(Qwt::Shape os)
00853 {
00854 d_canvas->setOutlineStyle(os);
00855 }
00856
00865 void QwtPlot::setOutlinePen(const QPen &pn)
00866 {
00867 d_canvas->setOutlinePen(pn);
00868 }
00869
00876 bool QwtPlot::outlineEnabled() const
00877 {
00878 return d_canvas->outlineEnabled();
00879 }
00880
00887 const QPen & QwtPlot::outlinePen() const
00888 {
00889 return d_canvas->outlinePen();
00890 }
00891
00900 Qwt::Shape QwtPlot::outlineStyle() const
00901 {
00902 return d_canvas->outlineStyle();
00903 }
00904
00905 #endif // ! QWT_NO_COMPAT
00906
00911 bool QwtPlot::axisValid(int axis)
00912 {
00913 return ((axis >= QwtPlot::yLeft) && (axis < QwtPlot::axisCnt));
00914 }
00915
00921 void QwtPlot::lgdClicked()
00922 {
00923 if ( sender()->isWidgetType() )
00924 {
00925 long key = d_legend->key((QWidget *)sender());
00926 if ( key >= 0 )
00927 emit legendClicked(key);
00928 }
00929 }
00930
00932 void QwtPlot::clear()
00933 {
00934 d_legend->clear();
00935 d_curves->clear();
00936 d_markers->clear();
00937 }
00938
00939
00941 void QwtPlot::removeCurves()
00942 {
00943 d_curves->clear();
00944 d_legend->clear();
00945 autoRefresh();
00946 }
00947
00949 void QwtPlot::removeMarkers()
00950 {
00951 d_markers->clear();
00952 autoRefresh();
00953 }
00954
00965 void QwtPlot::setAutoLegend(bool tf)
00966 {
00967 d_autoLegend = tf;
00968 }
00969
00973 bool QwtPlot::autoLegend() const
00974 {
00975 return d_autoLegend;
00976 }
00977
00978
00988 void QwtPlot::enableLegend(bool enable, long curveKey)
00989 {
00990 bool isUpdateEnabled = d_legend->isUpdatesEnabled();
00991 d_legend->setUpdatesEnabled(FALSE);
00992
00993 if ( curveKey < 0 )
00994 {
00995 if ( enable )
00996 {
00997 if ( d_legend->itemCount() < d_curves->count() )
00998 {
00999
01000
01001 d_legend->clear();
01002
01003 QwtPlotCurveIterator itc = curveIterator();
01004 for ( const QwtPlotCurve *curve = itc.toFirst();
01005 curve != 0; curve = ++itc )
01006 {
01007 insertLegendItem(itc.currentKey());
01008 }
01009 }
01010 }
01011 else
01012 {
01013 d_legend->clear();
01014 }
01015 }
01016 else
01017 {
01018 QWidget *legendItem = d_legend->findItem(curveKey);
01019 if ( enable )
01020 {
01021 if ( d_curves->find(curveKey) && !legendItem )
01022 insertLegendItem(curveKey);
01023 }
01024 else
01025 delete legendItem;
01026 }
01027
01028 d_legend->setUpdatesEnabled(isUpdateEnabled);
01029 updateLayout();
01030 }
01031
01037 bool QwtPlot::legendEnabled(long curveKey) const
01038 {
01039 return d_legend->findItem(curveKey) != 0;
01040 }
01041
01060 void QwtPlot::setLegendPosition(QwtPlot::Position pos, double ratio)
01061 {
01062 if (pos != d_layout->legendPosition())
01063 {
01064 d_layout->setLegendPosition(pos, ratio);
01065
01066 QLayout *l = d_legend->contentsWidget()->layout();
01067 if ( l && l->inherits("QwtDynGridLayout") )
01068 {
01069 QwtDynGridLayout *tl = (QwtDynGridLayout *)l;
01070 if ( d_layout->legendPosition() == QwtPlot::Top ||
01071 d_layout->legendPosition() == QwtPlot::Bottom )
01072 {
01073 tl->setMaxCols(0);
01074 }
01075 else
01076 tl->setMaxCols(1);
01077 }
01078
01079 updateLayout();
01080 updateTabOrder();
01081 }
01082 }
01083
01096 void QwtPlot::setLegendPosition(QwtPlot::Position pos)
01097 {
01098 setLegendPosition(pos, 0.0);
01099 }
01100
01105 QwtPlot::Position QwtPlot::legendPosition() const
01106 {
01107 return d_layout->legendPosition();
01108 }
01109
01110 #ifndef QWT_NO_COMPAT
01111
01131 void QwtPlot::setLegendPos(int pos, double ratio)
01132 {
01133 setLegendPosition(QwtPlot::Position(pos), ratio);
01134 }
01135
01141 int QwtPlot::legendPos() const
01142 {
01143 return d_layout->legendPosition();
01144 }
01145
01146 #endif // !QWT_NO_COMPAT
01147
01152 void QwtPlot::setLegendFont(const QFont &f)
01153 {
01154 d_legend->setFont(f);
01155 if (d_legend->isVisible())
01156 updateLayout();
01157 }
01158
01163 void QwtPlot::setLegendFrameStyle(int st)
01164 {
01165 d_legend->setFrameStyle(st);
01166 updateLayout();
01167 }
01168
01172 int QwtPlot::legendFrameStyle() const
01173 {
01174 return d_legend->frameStyle();
01175 }
01176
01180 const QFont QwtPlot::legendFont() const
01181 {
01182 return d_legend->font();
01183 }
01184
01191 void QwtPlot::setLegendDisplayPolicy(
01192 QwtLegend::LegendDisplayPolicy policy, int mode)
01193 {
01194 d_legend->setDisplayPolicy(policy, mode);
01195
01196 for (QwtPlotCurveIterator iter=curveIterator(); iter.current(); ++iter)
01197 updateLegendItem(iter.currentKey());
01198 }
01199
01200
01201
01202
01203
01204