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