void VectorPlot::addDotPlot(const MarkupQwtAdapter&adapter,
QColor color,
const QString &name,
bool addToLegend) {
QwtPlotCurve *curve = new QwtPlotCurve(name);
QwtSymbol sym;
sym.setPen(QColor(color));
sym.setBrush(QColor(color));
sym.setStyle(QwtSymbol::Rect);
sym.setSize(
QSize(1, 20)
);
curve->setSymbol(sym);
curve->setStyle(QwtPlotCurve::NoCurve);
if(adapter.size() > 0) {
setupPlot(adapter.boundingRect());
curve->setData(adapter);
curve->attach(plot);
}
if(!legend) {
return;
}
// Добавляем кривую в легенду
QwtLegendItem *item = new QwtLegendItem(0);
item->setText(curve->title());
item->setSymbol(sym);
item->setIdentifierMode(QwtLegendItem::ShowLine | QwtLegendItem::ShowSymbol | QwtLegendItem::ShowText);
legend->insert(curve, item);
}
void QwtPlotItem::updateLegend(QwtLegend *legend) const
{
if ( !legend )
return;
QWidget *lgdItem = legend->find(this);
if ( testItemAttribute(QwtPlotItem::Legend) )
{
if ( lgdItem == NULL )
{
lgdItem = legendItem();
if ( lgdItem )
{
if ( lgdItem->inherits("QwtLegendItem") )
{
QwtLegendItem *label = (QwtLegendItem *)lgdItem;
label->setItemMode(legend->itemMode());
if ( d_data->plot )
{
QObject::connect(label, SIGNAL(clicked()),
d_data->plot, SLOT(legendItemClicked()));
QObject::connect(label, SIGNAL(checked(bool)),
d_data->plot, SLOT(legendItemChecked(bool)));
}
}
legend->insert(this, lgdItem);
}
void GenericHistogramView::init()
{
this->setMouseTracking(true); //Switch on mouse tracking (no need to press button)
_qwtPlot->setTitle("Histogram");
_qwtPlot->setCanvasBackground(QColor(Qt::gray));
_qwtPlot->plotLayout()->setAlignCanvasToScales(true);
_qwtPlot->setAxisTitle(QwtPlot::yLeft, "Number of specimen");
_qwtPlot->setAxisTitle(QwtPlot::xBottom, "Pixel value");
QwtLegend* legend = new QwtLegend();
legend->setItemMode(QwtLegend::CheckableItem);
_qwtPlot->insertLegend(legend, QwtPlot::RightLegend);
populate();
_qwtPlot->canvas()->setMouseTracking(true);
if(_horizontal)
_principalPicker = new HistogramPicker(QwtPlotPicker::HLineRubberBand, QwtPicker::AlwaysOn, _qwtPlot->canvas());
else
_principalPicker = new HistogramPicker(QwtPlotPicker::VLineRubberBand, QwtPicker::AlwaysOn, _qwtPlot->canvas());
_principalPicker->setStateMachine(new QwtPickerDragPointMachine());
_principalPicker->setTrackerPen(QColor(Qt::white));
_principalPicker->setRubberBandPen(QColor(Qt::yellow));
_leftPicker = new HistogramPicker(_qwtPlot->canvas());
_leftPicker->setStateMachine(new QwtPickerDragPointMachine());
_rightPicker = new HistogramPicker(_qwtPlot->canvas());
_rightPicker->setStateMachine(new QwtPickerDragPointMachine());
_rightPicker->setRubberBand(QwtPlotPicker::VLineRubberBand);
_rightPicker->setRubberBandPen(QColor(Qt::yellow));
_rightPicker->setMousePattern(QwtPicker::MouseSelect1, Qt::RightButton);
connect(_qwtPlot, SIGNAL(legendChecked(QwtPlotItem*, bool)), this, SLOT(showItem(QwtPlotItem*, bool)));
connect(_rightPicker, SIGNAL(selected(const QPointF&)), this, SLOT(rightClick(const QPointF&)));
connect(_leftPicker, SIGNAL(selected(const QPointF&)), this, SLOT(leftClick(const QPointF&)));
connect(_principalPicker, SIGNAL(moved(const QPointF&)), this, SLOT(move(const QPointF&)));
_qwtPlot->replot(); // creating the legend items
QwtPlotItemList items = _qwtPlot->itemList(QwtPlotItem::Rtti_PlotHistogram);
for(int i = 0; i < items.size(); i++)
{
QwtLegendItem* legendItem = qobject_cast<QwtLegendItem*>(legend->find(items[i]));
if(legendItem)
legendItem->setChecked(true);
items[i]->setVisible(true);
}
_qwtPlot->setAutoReplot(true);
}
void MainWindow::showCurve(QwtPlotItem *item, bool on)
{
item->setVisible(on);
QwtLegendItem *legendItem = qobject_cast<QwtLegendItem*>(ui->plot->legend()->find(item));
if (legendItem) {
legendItem->setChecked(on);
}
}
void MainWindow::sampleFormatChanged()
{
for (int i = 0; i < curves.size(); i++) {
curves[i].curve->detach();
delete curves[i].curve;
curves[i].data->clear();
delete curves[i].data;
}
curves.clear();
timeAxis.clear();
QList<sampleValue> sampleList = kwp.getSample();
int numSamples = settingsDialog->rate * settingsDialog->historySecs + 1;
timeAxis.clear();
for (int i = 0; i < numSamples; i++) {
timeAxis.prepend(-i / static_cast<double>(settingsDialog->rate));
}
int numColors = sizeof(colorList) / sizeof(QString);
for (int i = 0; i < sampleList.length(); i++) {
QwtPlotCurve* curve = new QwtPlotCurve;
QVector<double>* data = new QVector<double>();
data->reserve(numSamples+1);
data->fill(0, numSamples);
QColor curveColor;
curveColor.setNamedColor(colorList[i % numColors]);
int blockNum = sampleList.at(i).refs.at(0).blockNum;
int pos = sampleList.at(i).refs.at(0).pos;
blockLabels_t label = kwp.getBlockLabel(blockNum);
QString desc = label.desc[pos] + " " + label.subDesc[pos];
curve->setRenderHint(QwtPlotItem::RenderAntialiased);
curve->setPen(curveColor);
curve->setTitle(desc);
curve->setRawSamples(timeAxis.constData(), data->constData(), numSamples);
curve->attach(ui->plot);
// set legend checked
QwtLegendItem *legendItem = qobject_cast<QwtLegendItem*>(ui->plot->legend()->find(curve));
if (legendItem) {
legendItem->setChecked(true);
}
curveAndData tmp;
tmp.curve = curve;
tmp.data = data;
curves.append(tmp);
}
}
void PlotCurve::updateLegend(QwtLegend *legend) const
{
QwtPlotCurve::updateLegend(legend);
QwtLegendItem *pQwtLegendItem = dynamic_cast<QwtLegendItem*>(legend->find(this));
if (pQwtLegendItem)
{
pQwtLegendItem->setIdentifierMode(QwtLegendItem::ShowLine);
pQwtLegendItem->setIdentifierWidth(30);
}
QwtPlotItem::updateLegend(legend);
}
/*!
\brief Update the widget that represents the item on the legend
updateLegend() is called from itemChanged() to adopt the widget
representing the item on the legend to its new configuration.
The default implementation is made for QwtPolarCurve and updates a
QwtLegendItem(), but an item could be represented by any type of widget,
by overloading legendItem() and updateLegend().
\sa legendItem(), itemChanged(), QwtLegend()
*/
void QwtPolarItem::updateLegend( QwtLegend *legend ) const
{
if ( legend == NULL )
return;
QWidget *lgdItem = legend->find( this );
if ( testItemAttribute( QwtPolarItem::Legend ) )
{
if ( lgdItem == NULL )
{
lgdItem = legendItem();
if ( lgdItem )
legend->insert( this, lgdItem );
}
QwtLegendItem* label = qobject_cast<QwtLegendItem *>( lgdItem );
if ( label )
{
// paint the identifier
const QSize sz = label->identifierSize();
QPixmap identifier( sz.width(), sz.height() );
identifier.fill( Qt::transparent );
QPainter painter( &identifier );
painter.setRenderHint( QPainter::Antialiasing,
testRenderHint( QwtPolarItem::RenderAntialiased ) );
drawLegendIdentifier( &painter,
QRect( 0, 0, sz.width(), sz.height() ) );
painter.end();
const bool doUpdate = label->updatesEnabled();
if ( doUpdate )
label->setUpdatesEnabled( false );
label->setText( title() );
label->setIdentifier( identifier );
label->setItemMode( legend->itemMode() );
if ( doUpdate )
label->setUpdatesEnabled( true );
label->update();
}
}
else
{
if ( lgdItem )
{
lgdItem->hide();
lgdItem->deleteLater();
}
}
}
//---------------------------------------------------------------------------
void JrkPlotDialog::showCurve(QwtPlotItem *item, bool on)
{
//qDebug("showCurve");
item->setVisible(on);
QwtLegendItem *legendItem =
qobject_cast<QwtLegendItem *>(ui->jrkPlot->legend()->find(item));
if(legendItem)
legendItem->setChecked(on);
//ui->jrkPlot->replot();
}
void LineChart::setTooltip(QString t)
{
tooltip = t;
QwtPlot *p = plot();
if (p == NULL)
return;
QwtLegend *l = p->legend();
if (l == NULL)
return;
QwtLegendItem *legendItem = (QwtLegendItem *)l->find(this);
if (legendItem != NULL)
legendItem->setToolTip(tooltip);
}
void Legend::legendMenu(const QPoint& pos)
{
QwtLegendItem *lgdItem = dynamic_cast<QwtLegendItem*>(childAt(pos));
if(lgdItem)
{
mLegendItemStr = lgdItem->text().text();
QMenu menu(mpPlot);
menu.addAction(mpChangeColorAction);
menu.addAction(mpAutomaticColorAction);
menu.addSeparator();
menu.addAction(mpHideAction);
menu.exec(mapToGlobal(pos));
}
}
//! Update the widget that represents the curve on the legend
void QwtPolarCurve::updateLegend( QwtLegend *legend ) const
{
if ( legend && testItemAttribute( QwtPolarCurve::Legend )
&& ( d_data->legendAttributes & QwtPolarCurve::LegendShowSymbol )
&& d_data->symbol
&& d_data->symbol->style() != QwtSymbol::NoSymbol )
{
QWidget *lgdItem = legend->find( this );
if ( lgdItem == NULL )
{
lgdItem = legendItem();
if ( lgdItem )
legend->insert( this, lgdItem );
}
QwtLegendItem *l = qobject_cast<QwtLegendItem *>( lgdItem );
if ( l )
{
QSize sz = d_data->symbol->boundingSize();
sz += QSize( 2, 2 ); // margin
if ( d_data->legendAttributes & QwtPolarCurve::LegendShowLine )
{
// Avoid, that the line is completely covered by the symbol
int w = qCeil( 1.5 * sz.width() );
if ( w % 2 )
w++;
sz.setWidth( qMax( 8, w ) );
}
l->setIdentifierSize( sz );
}
}
QwtPolarItem::updateLegend( legend );
}
/*!
\brief Update the widget that represents the item on the legend
\param legend Legend
\sa drawLegendIdentifier(), legendItem(), itemChanged(), QwtLegend()
*/
void QwtPlotCurve::updateLegend( QwtLegend *legend ) const
{
if ( legend && testItemAttribute( QwtPlotItem::Legend )
&& ( d_data->legendAttributes & QwtPlotCurve::LegendShowSymbol )
&& d_data->symbol
&& d_data->symbol->style() != QwtSymbol::NoSymbol )
{
QWidget *lgdItem = legend->find( this );
if ( lgdItem == NULL )
{
lgdItem = legendItem();
if ( lgdItem )
legend->insert( this, lgdItem );
}
if ( lgdItem && lgdItem->inherits( "QwtLegendItem" ) )
{
QwtLegendItem *l = ( QwtLegendItem * )lgdItem;
l->setIdentifierSize( d_data->symbol->boundingSize() );
}
}
QwtPlotItem::updateLegend( legend );
}
void QwtPlot::printLegend(QPainter *painter, const QRect &rect) const
{
if ( !legend() || legend()->isEmpty() )
return;
QLayout *l = legend()->contentsWidget()->layout();
if ( l == 0 || !l->inherits("QwtDynGridLayout") )
return;
QwtDynGridLayout *legendLayout = (QwtDynGridLayout *)l;
uint numCols = legendLayout->columnsForWidth(rect.width());
#if QT_VERSION < 0x040000
QValueList<QRect> itemRects =
legendLayout->layoutItems(rect, numCols);
#else
QList<QRect> itemRects =
legendLayout->layoutItems(rect, numCols);
#endif
int index = 0;
#if QT_VERSION < 0x040000
QLayoutIterator layoutIterator = legendLayout->iterator();
for ( QLayoutItem *item = layoutIterator.current();
item != 0; item = ++layoutIterator) {
#else
for ( int i = 0; i < legendLayout->count(); i++ ) {
QLayoutItem *item = legendLayout->itemAt(i);
#endif
QWidget *w = item->widget();
if ( w ) {
painter->save();
painter->setClipping(true);
QwtPainter::setClipRect(painter, itemRects[index]);
printLegendItem(painter, w, itemRects[index]);
index++;
painter->restore();
}
}
}
/*!
Print the legend item into a given rectangle.
\param painter Painter
\param w Widget representing a legend item
\param rect Bounding rectangle
*/
void QwtPlot::printLegendItem(QPainter *painter,
const QWidget *w, const QRect &rect) const
{
if ( w->inherits("QwtLegendItem") ) {
QwtLegendItem *item = (QwtLegendItem *)w;
painter->setFont(item->font());
item->drawItem(painter, rect);
}
}
/*!
\brief Paint a scale into a given rectangle.
Paint the scale into a given rectangle.
\param painter Painter
\param axisId Axis
\param startDist Start border distance
\param endDist End border distance
\param baseDist Base distance
\param rect Bounding rectangle
*/
void QwtPlot::printScale(QPainter *painter,
int axisId, int startDist, int endDist, int baseDist,
const QRect &rect) const
{
if (!axisEnabled(axisId))
return;
const QwtScaleWidget *scaleWidget = axisWidget(axisId);
if ( scaleWidget->isColorBarEnabled()
&& scaleWidget->colorBarWidth() > 0) {
const QwtMetricsMap map = QwtPainter::metricsMap();
QRect r = map.layoutToScreen(rect);
r.setWidth(r.width() - 1);
r.setHeight(r.height() - 1);
scaleWidget->drawColorBar(painter, scaleWidget->colorBarRect(r));
const int off = scaleWidget->colorBarWidth() + scaleWidget->spacing();
if ( scaleWidget->scaleDraw()->orientation() == Qt::Horizontal )
baseDist += map.screenToLayoutY(off);
else
baseDist += map.screenToLayoutX(off);
}
QwtScaleDraw::Alignment align;
int x, y, w;
switch(axisId) {
case yLeft: {
x = rect.right() - baseDist;
y = rect.y() + startDist;
w = rect.height() - startDist - endDist;
align = QwtScaleDraw::LeftScale;
break;
}
case yRight: {
x = rect.left() + baseDist;
y = rect.y() + startDist;
w = rect.height() - startDist - endDist;
align = QwtScaleDraw::RightScale;
break;
}
case xTop: {
x = rect.left() + startDist;
y = rect.bottom() - baseDist;
w = rect.width() - startDist - endDist;
align = QwtScaleDraw::TopScale;
break;
}
case xBottom: {
x = rect.left() + startDist;
y = rect.top() + baseDist;
w = rect.width() - startDist - endDist;
align = QwtScaleDraw::BottomScale;
break;
}
default:
return;
}
scaleWidget->drawTitle(painter, align, rect);
painter->save();
painter->setFont(scaleWidget->font());
QPen pen = painter->pen();
pen.setWidth(scaleWidget->penWidth());
painter->setPen(pen);
QwtScaleDraw *sd = (QwtScaleDraw *)scaleWidget->scaleDraw();
const QPoint sdPos = sd->pos();
const int sdLength = sd->length();
sd->move(x, y);
sd->setLength(w);
#if QT_VERSION < 0x040000
sd->draw(painter, scaleWidget->palette().active());
#else
QPalette palette = scaleWidget->palette();
palette.setCurrentColorGroup(QPalette::Active);
sd->draw(painter, palette);
#endif
// reset previous values
sd->move(sdPos);
sd->setLength(sdLength);
painter->restore();
}
/*!
Print the canvas into a given rectangle.
\param painter Painter
\param map Maps mapping between plot and paint device coordinates
\param boundingRect Bounding rectangle
\param canvasRect Canvas rectangle
\param pfilter Print filter
\sa QwtPlotPrintFilter
*/
void QwtPlot::printCanvas(QPainter *painter,
const QRect &boundingRect, const QRect &canvasRect,
const QwtScaleMap map[axisCnt], const QwtPlotPrintFilter &pfilter) const
{
if ( pfilter.options() & QwtPlotPrintFilter::PrintBackground ) {
QBrush bgBrush;
#if QT_VERSION >= 0x040000
bgBrush = canvas()->palette().brush(backgroundRole());
#else
QColorGroup::ColorRole role =
QPalette::backgroundRoleFromMode( backgroundMode() );
bgBrush = canvas()->colorGroup().brush( role );
#endif
QRect r = boundingRect;
if ( !(pfilter.options() & QwtPlotPrintFilter::PrintFrameWithScales) ) {
r = canvasRect;
#if QT_VERSION >= 0x040000
// Unfortunately the paint engines do no always the same
const QPaintEngine *pe = painter->paintEngine();
if ( pe ) {
switch(painter->paintEngine()->type() ) {
case QPaintEngine::Raster:
case QPaintEngine::X11:
break;
default:
r.setWidth(r.width() - 1);
r.setHeight(r.height() - 1);
break;
}
}
#else
if ( painter->device()->isExtDev() ) {
r.setWidth(r.width() - 1);
r.setHeight(r.height() - 1);
}
#endif
}
QwtPainter::fillRect(painter, r, bgBrush);
}
if ( pfilter.options() & QwtPlotPrintFilter::PrintFrameWithScales ) {
painter->save();
painter->setPen(QPen(Qt::black));
painter->setBrush(QBrush(Qt::NoBrush));
QwtPainter::drawRect(painter, boundingRect);
painter->restore();
}
painter->setClipping(true);
QwtPainter::setClipRect(painter, canvasRect);
drawItems(painter, canvasRect, map, pfilter);
}
void QwtPolarPlot::renderLegend( QPainter *painter, const QRect &rect ) const
{
#if 1
// Shift this code into QwtLegend, so that Qwt/QwtPolar can share it
#endif
if ( !legend() || legend()->isEmpty() )
return;
QLayout *l = legend()->contentsWidget()->layout();
if ( l == 0 || !l->inherits( "QwtDynGridLayout" ) )
return;
QwtDynGridLayout *legendLayout = ( QwtDynGridLayout * )l;
uint numCols = legendLayout->columnsForWidth( rect.width() );
#if QT_VERSION < 0x040000
QValueList<QRect> itemRects =
legendLayout->layoutItems( rect, numCols );
#else
QList<QRect> itemRects =
legendLayout->layoutItems( rect, numCols );
#endif
int index = 0;
#if QT_VERSION < 0x040000
QLayoutIterator layoutIterator = legendLayout->iterator();
for ( QLayoutItem *item = layoutIterator.current();
item != 0; item = ++layoutIterator )
{
#else
for ( int i = 0; i < legendLayout->count(); i++ )
{
QLayoutItem *item = legendLayout->itemAt( i );
#endif
QWidget *w = item->widget();
if ( w )
{
painter->save();
painter->setClipping( true );
QwtPainter::setClipRect( painter, itemRects[index] );
renderLegendItem( painter, w, itemRects[index] );
index++;
painter->restore();
}
}
}
/*!
Render the legend item into a given rectangle.
\param painter Painter
\param w Widget representing a legend item
\param rect Bounding rectangle
*/
void QwtPolarPlot::renderLegendItem( QPainter *painter,
const QWidget *w, const QRect &rect ) const
{
#if 1
// Shift this code into QwtLegend, so that Qwt/QwtPolar can share it
#endif
if ( w->inherits( "QwtLegendItem" ) )
{
QwtLegendItem *item = ( QwtLegendItem * )w;
painter->setFont( item->font() );
item->drawItem( painter, rect );
}
}
//! Update the widget that represents the curve on the legend
// this was adapted from QwtPlotCurve::updateLegend()
void HistogramItem::updateLegend( QwtLegend *legend ) const
{
if ( !legend )
return;
QwtPlotItem::updateLegend( legend );
QWidget *widget = legend->find( this );
if ( !widget || !widget->inherits( "QwtLegendItem" ) )
return;
QwtLegendItem *legendItem = ( QwtLegendItem * )widget;
const bool doUpdate = legendItem->updatesEnabled();
legendItem->setUpdatesEnabled( false );
const int policy = legend->displayPolicy();
if ( policy == QwtLegend::FixedIdentifier )
{
int mode = legend->identifierMode();
legendItem->setCurvePen( QPen( color() ) );
if ( mode & QwtLegendItem::ShowText )
legendItem->setText( title() );
else
legendItem->setText( QwtText() );
legendItem->setIdentifierMode( mode );
}
else if ( policy == QwtLegend::AutoIdentifier )
{
int mode = 0;
legendItem->setCurvePen( QPen( color() ) );
mode |= QwtLegendItem::ShowLine;
if ( !title().isEmpty() )
{
legendItem->setText( title() );
mode |= QwtLegendItem::ShowText;
}
else
{
legendItem->setText( QwtText() );
}
legendItem->setIdentifierMode( mode );
}
legendItem->setUpdatesEnabled( doUpdate );
legendItem->update();
}
//! Update the widget that represents the curve on the legend
void QwtPlotCurve::updateLegend(QwtLegend *legend) const
{
if ( !legend )
return;
QwtPlotItem::updateLegend(legend);
QWidget *widget = legend->find(this);
if ( !widget || !widget->inherits("QwtLegendItem") )
return;
QwtLegendItem *legendItem = (QwtLegendItem *)widget;
#if QT_VERSION < 0x040000
const bool doUpdate = legendItem->isUpdatesEnabled();
#else
const bool doUpdate = legendItem->updatesEnabled();
#endif
legendItem->setUpdatesEnabled(false);
const int policy = legend->displayPolicy();
if (policy == QwtLegend::FixedIdentifier)
{
int mode = legend->identifierMode();
if (mode & QwtLegendItem::ShowLine)
legendItem->setCurvePen(pen());
if (mode & QwtLegendItem::ShowSymbol)
legendItem->setSymbol(symbol());
if (mode & QwtLegendItem::ShowText)
legendItem->setText(title());
else
legendItem->setText(QwtText());
legendItem->setIdentifierMode(mode);
}
else if (policy == QwtLegend::AutoIdentifier)
{
int mode = 0;
if (QwtPlotCurve::NoCurve != style())
{
legendItem->setCurvePen(pen());
mode |= QwtLegendItem::ShowLine;
}
if (QwtSymbol::NoSymbol != symbol().style())
{
legendItem->setSymbol(symbol());
mode |= QwtLegendItem::ShowSymbol;
}
if ( !title().isEmpty() )
{
legendItem->setText(title());
mode |= QwtLegendItem::ShowText;
}
else
{
legendItem->setText(QwtText());
}
legendItem->setIdentifierMode(mode);
}
legendItem->setUpdatesEnabled(doUpdate);
legendItem->update();
}
LevelOneMuChart::LevelOneMuChart(QWidget *parent)
: QwtPlot(parent)
{
setAutoReplot(false);
/* Panning with the left mouse button */
(void)new QwtPlotPanner(canvas());
/* Zoom in/out with the wheel */
(void)new QwtPlotMagnifier(canvas());
/* Picker */
plotPicker = new QwtPlotPicker(QwtPlot::xBottom,
QwtPlot::yLeft,
QwtPlotPicker::CrossRubberBand,
QwtPicker::AlwaysOn,
canvas());
plotPicker->setStateMachine(new QwtPickerDragPointMachine());
plotPicker->setRubberBandPen(QColor(Qt::blue));
plotPicker->setRubberBand(QwtPicker::CrossRubberBand);
plotPicker->setTrackerPen(QColor(Qt::black));
setAutoFillBackground(true);
setPalette(QPalette(QColor(199, 237, 255))); // Light Blue
updateWidgetGradient();
setTitle(tr("Chart of available deviations"));
/* Legend */
legend = new QwtLegend();
legend->setItemMode(QwtLegend::CheckableItem);
insertLegend(legend, QwtPlot::RightLegend);
/* Canvas Settings */
canvas()->setLineWidth(1);
canvas()->setFrameStyle(QFrame::Box | QFrame::Plain);
QPalette canvasPalette(Qt::white);
canvasPalette.setColor(QPalette::Foreground, QColor(133, 190, 232));
canvas()->setPalette(canvasPalette);
plotAssay();
/* Legend */
connect(this, SIGNAL(legendChecked(QwtPlotItem *, bool)),
SLOT(showItem(QwtPlotItem *, bool)));
QwtPlotItemList items = itemList(QwtPlotItem::Rtti_PlotCurve);
for (int i = 0; i < items.size(); i++)
{
if (i < 3)
{
QwtLegendItem *legendItem =
qobject_cast<QwtLegendItem *>(legend->find(items[i]));
if (legendItem)
{
legendItem->setChecked(true);
}
items[i]->setVisible(true);
}
else
{
items[i]->setVisible(false);
}
}
setAutoReplot(true);
}
/*!
Reset color and fonts of a plot
\sa apply()
*/
void QwtPlotPrintFilter::reset(QwtPlot *plot) const
{
if ( d_data->cache == 0 )
return;
const bool doAutoReplot = plot->autoReplot();
plot->setAutoReplot(false);
const PrivateData::Cache &cache = *d_data->cache;
if ( plot->titleLabel() )
{
QwtTextLabel* title = plot->titleLabel();
if ( title->text().testPaintAttribute(QwtText::PaintUsingTextFont) )
{
QwtText text = title->text();
text.setColor(cache.titleColor);
title->setText(text);
}
else
{
QPalette palette = title->palette();
palette.setColor(
QPalette::Active, Palette::Text, cache.titleColor);
title->setPalette(palette);
}
if ( title->text().testPaintAttribute(QwtText::PaintUsingTextFont) )
{
QwtText text = title->text();
text.setFont(cache.titleFont);
title->setText(text);
}
else
{
title->setFont(cache.titleFont);
}
}
if ( plot->legend() )
{
#if QT_VERSION < 0x040000
QValueList<QWidget *> list = plot->legend()->legendItems();
for ( QValueListIterator<QWidget *> it = list.begin();
it != list.end(); ++it )
#else
QList<QWidget *> list = plot->legend()->legendItems();
for ( QList<QWidget*>::iterator it = list.begin();
it != list.end(); ++it )
#endif
{
QWidget *w = *it;
if ( cache.legendFonts.contains(w) )
w->setFont(cache.legendFonts[w]);
if ( w->inherits("QwtLegendItem") )
{
QwtLegendItem *label = (QwtLegendItem *)w;
const QwtPlotItem *plotItem =
(const QwtPlotItem*)plot->legend()->find(label);
QwtSymbol symbol = label->symbol();
if ( cache.curveSymbolPenColors.contains(plotItem) )
{
QPen pen = symbol.pen();
pen.setColor(cache.curveSymbolPenColors[plotItem]);
symbol.setPen(pen);
}
if ( cache.curveSymbolBrushColors.contains(plotItem) )
{
QBrush brush = symbol.brush();
brush.setColor(cache.curveSymbolBrushColors[plotItem]);
symbol.setBrush(brush);
}
label->setSymbol(symbol);
if ( cache.curveColors.contains(plotItem) )
{
QPen pen = label->curvePen();
pen.setColor(cache.curveColors[plotItem]);
label->setCurvePen(pen);
}
}
}
}
for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
{
QwtScaleWidget *scaleWidget = plot->axisWidget(axis);
if ( scaleWidget )
{
QPalette palette = scaleWidget->palette();
palette.setColor(QPalette::Active, Palette::Foreground,
cache.scaleColor[axis]);
scaleWidget->setPalette(palette);
scaleWidget->setFont(cache.scaleFont[axis]);
scaleWidget->setTitle(cache.scaleTitle[axis]);
int startDist, endDist;
scaleWidget->getBorderDistHint(startDist, endDist);
scaleWidget->setBorderDist(startDist, endDist);
}
}
if ( hasBackgroundColor(plot) )
{
QPalette p = plot->palette();
p.setColor(QPalette::Active, Palette::Background, cache.widgetBackground);
plot->setPalette(p);
}
if ( hasBackgroundColor(plot->canvas()) )
{
plot->setCanvasBackground(cache.canvasBackground);
}
const QwtPlotItemList& itmList = plot->itemList();
for ( QwtPlotItemIterator it = itmList.begin();
it != itmList.end(); ++it )
{
reset(*it);
}
delete d_data->cache;
d_data->cache = 0;
plot->setAutoReplot(doAutoReplot);
}
/*!
Change color and fonts of a plot
\sa apply()
*/
void QwtPlotPrintFilter::apply(QwtPlot *plot) const
{
const bool doAutoReplot = plot->autoReplot();
plot->setAutoReplot(false);
delete d_data->cache;
d_data->cache = new PrivateData::Cache;
PrivateData::Cache &cache = *d_data->cache;
if ( plot->titleLabel() )
{
QPalette palette = plot->titleLabel()->palette();
cache.titleColor = palette.color(
QPalette::Active, Palette::Text);
palette.setColor(QPalette::Active, Palette::Text,
color(cache.titleColor, Title));
plot->titleLabel()->setPalette(palette);
cache.titleFont = plot->titleLabel()->font();
plot->titleLabel()->setFont(font(cache.titleFont, Title));
}
if ( plot->legend() )
{
#if QT_VERSION < 0x040000
QValueList<QWidget *> list = plot->legend()->legendItems();
for ( QValueListIterator<QWidget *> it = list.begin();
it != list.end(); ++it )
#else
QList<QWidget *> list = plot->legend()->legendItems();
for ( QList<QWidget*>::iterator it = list.begin();
it != list.end(); ++it )
#endif
{
QWidget *w = *it;
cache.legendFonts.insert(w, w->font());
w->setFont(font(w->font(), Legend));
if ( w->inherits("QwtLegendItem") )
{
QwtLegendItem *label = (QwtLegendItem *)w;
QwtSymbol symbol = label->symbol();
QPen pen = symbol.pen();
QBrush brush = symbol.brush();
pen.setColor(color(pen.color(), CurveSymbol));
brush.setColor(color(brush.color(), CurveSymbol));
symbol.setPen(pen);
symbol.setBrush(brush);
label->setSymbol(symbol);
pen = label->curvePen();
pen.setColor(color(pen.color(), Curve));
label->setCurvePen(pen);
}
}
}
for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
{
QwtScaleWidget *scaleWidget = plot->axisWidget(axis);
if ( scaleWidget )
{
cache.scaleColor[axis] = scaleWidget->palette().color(
QPalette::Active, Palette::Foreground);
QPalette palette = scaleWidget->palette();
palette.setColor(QPalette::Active, Palette::Foreground,
color(cache.scaleColor[axis], AxisScale));
scaleWidget->setPalette(palette);
cache.scaleFont[axis] = scaleWidget->font();
scaleWidget->setFont(font(cache.scaleFont[axis], AxisScale));
cache.scaleTitle[axis] = scaleWidget->title();
QwtText scaleTitle = scaleWidget->title();
if ( scaleTitle.testPaintAttribute(QwtText::PaintUsingTextColor) )
{
cache.scaleTitleColor[axis] = scaleTitle.color();
scaleTitle.setColor(
color(cache.scaleTitleColor[axis], AxisTitle));
}
if ( scaleTitle.testPaintAttribute(QwtText::PaintUsingTextFont) )
{
cache.scaleTitleFont[axis] = scaleTitle.font();
scaleTitle.setFont(
font(cache.scaleTitleFont[axis], AxisTitle));
}
scaleWidget->setTitle(scaleTitle);
int startDist, endDist;
scaleWidget->getBorderDistHint(startDist, endDist);
scaleWidget->setBorderDist(startDist, endDist);
}
}
if ( hasBackgroundColor(plot) )
{
QPalette p = plot->palette();
cache.widgetBackground = plot->palette().color(
QPalette::Active, Palette::Background);
p.setColor(QPalette::Active, Palette::Background,
color(cache.widgetBackground, WidgetBackground));
plot->setPalette(p);
}
if ( hasBackgroundColor(plot->canvas()))
{
cache.canvasBackground = plot->canvasBackground();
plot->setCanvasBackground(color(cache.canvasBackground, CanvasBackground));
}
const QwtPlotItemList& itmList = plot->itemList();
for ( QwtPlotItemIterator it = itmList.begin();
it != itmList.end(); ++it )
{
apply(*it);
}
plot->setAutoReplot(doAutoReplot);
}
void QwtPlot::printLegend(QPainter *painter, const QRect &rect) const
{
if ( !legend() || legend()->isEmpty() )
return;
QLayout *l = legend()->contentsWidget()->layout();
if ( l == 0 || !l->inherits("QwtDynGridLayout") )
return;
QwtDynGridLayout *legendLayout = (QwtDynGridLayout *)l;
uint numCols = legendLayout->columnsForWidth(rect.width());
#if QT_VERSION < 0x040000
QValueList<QRect> itemRects =
legendLayout->layoutItems(rect, numCols);
#else
QList<QRect> itemRects =
legendLayout->layoutItems(rect, numCols);
#endif
int index = 0;
#if QT_VERSION < 0x040000
QLayoutIterator layoutIterator = legendLayout->iterator();
for ( QLayoutItem *item = layoutIterator.current();
item != 0; item = ++layoutIterator)
{
#else
for ( int i = 0; i < legendLayout->count(); i++ )
{
QLayoutItem *item = legendLayout->itemAt(i);
#endif
QWidget *w = item->widget();
if ( w )
{
painter->save();
painter->setClipping(true);
QwtPainter::setClipRect(painter, itemRects[index]);
printLegendItem(painter, w, itemRects[index]);
index++;
painter->restore();
}
}
}
/*!
Print the legend item into a given rectangle.
\param painter Painter
\param w Widget representing a legend item
\param rect Bounding rectangle
*/
void QwtPlot::printLegendItem(QPainter *painter,
const QWidget *w, const QRect &rect) const
{
if ( w->inherits("QwtLegendItem") )
{
QwtLegendItem *item = (QwtLegendItem *)w;
painter->setFont(item->font());
item->drawItem(painter, rect);
}
}
/*!
\brief Paint a scale into a given rectangle.
Paint the scale into a given rectangle.
\param painter Painter
\param axisId Axis
\param startDist Start border distance
\param endDist End border distance
\param baseDist Base distance
\param rect Bounding rectangle
*/
void QwtPlot::printScale(QPainter *painter,
int axisId, int startDist, int endDist, int baseDist,
const QRect &rect) const
{
if (!axisEnabled(axisId))
return;
QwtScaleDraw::Alignment align;
int x, y, w;
switch(axisId)
{
case yLeft:
{
x = rect.right() - baseDist + 1;
y = rect.y() + startDist;
w = rect.height() - startDist - endDist;
align = QwtScaleDraw::LeftScale;
break;
}
case yRight:
{
x = rect.left() + baseDist;
y = rect.y() + startDist;
w = rect.height() - startDist - endDist;
align = QwtScaleDraw::RightScale;
break;
}
case xTop:
{
x = rect.left() + startDist;
y = rect.bottom() - baseDist + 1;
w = rect.width() - startDist - endDist;
align = QwtScaleDraw::TopScale;
break;
}
case xBottom:
{
x = rect.left() + startDist;
y = rect.top() + baseDist;
w = rect.width() - startDist - endDist;
align = QwtScaleDraw::BottomScale;
break;
}
default:
return;
}
const QwtScaleWidget *scaleWidget = axisWidget(axisId);
scaleWidget->drawTitle(painter, align, rect);
painter->save();
painter->setFont(scaleWidget->font());
QwtScaleDraw *sd = (QwtScaleDraw *)scaleWidget->scaleDraw();
const QPoint sdPos = sd->pos();
const int sdLength = sd->length();
sd->move(x, y);
sd->setLength(w);
#if QT_VERSION < 0x040000
sd->draw(painter, scaleWidget->palette().active());
#else
QPalette palette = scaleWidget->palette();
palette.setCurrentColorGroup(QPalette::Active);
sd->draw(painter, palette);
#endif
// reset previous values
sd->move(sdPos);
sd->setLength(sdLength);
painter->restore();
}
/*!
Print the canvas into a given rectangle.
\param painter Painter
\param map Maps mapping between plot and paint device coordinates
\param canvasRect Bounding rectangle
\param pfilter Print filter
\sa QwtPlotPrintFilter
*/
void QwtPlot::printCanvas(QPainter *painter, const QRect &canvasRect,
const QwtArray<QwtScaleMap> &map, const QwtPlotPrintFilter &pfilter) const
{
if ( pfilter.options() & QwtPlotPrintFilter::PrintCanvasBackground )
{
painter->setPen(Qt::NoPen);
QBrush bgBrush;
#if QT_VERSION >= 0x040000
bgBrush = canvas()->palette().brush(backgroundRole());
#else
QColorGroup::ColorRole role =
QPalette::backgroundRoleFromMode( backgroundMode() );
bgBrush = canvas()->colorGroup().brush( role );
#endif
painter->setBrush(bgBrush);
int x1 = 0;
int x2 = 0;
int y1 = 0;
int y2 = 0;
#if QT_VERSION >= 0x040000
switch(painter->device()->paintEngine()->type())
{
case QPaintEngine::PostScript:
x2 = 1;
y2 = 1;
break;
default:;
}
#endif
const QwtMetricsMap map = QwtPainter::metricsMap();
x1 = map.screenToLayoutX(x1);
x2 = map.screenToLayoutX(x2);
y1 = map.screenToLayoutY(y1);
y2 = map.screenToLayoutY(y2);
QwtPainter::drawRect(painter,
canvasRect.x() + x1, canvasRect.y() + y1,
canvasRect.width() - x2, canvasRect.height() - y2);
}
else
{
// Paint the canvas borders instead.
painter->setPen(QPen(Qt::black));
painter->setBrush(QBrush(Qt::NoBrush));
QwtPainter::drawRect(painter, canvasRect);
}
painter->setClipping(true);
QwtPainter::setClipRect(painter, canvasRect);
drawItems(painter, canvasRect, map, pfilter);
}