/*!
\brief Paint the plot into a given rectangle.
Paint the contents of a QwtPlot instance into a given rectangle.
\param painter Painter
\param plotRect Bounding rectangle
\param pfilter Print filter
\sa QwtPlotPrintFilter
*/
void QwtPlot::print(QPainter *painter, const QRect &plotRect,
const QwtPlotPrintFilter &pfilter) const
{
int axisId;
if ( painter == 0 || !painter->isActive() ||
!plotRect.isValid() || size().isNull() )
return;
painter->save();
#if 1
/*
PDF: In Qt4 ( <= 4.3.2 ) the scales are painted in gray instead of
black. See http://trolltech.com/developer/task-tracker/index_html?id=184671&method=entry
The dummy lines below work around the problem.
*/
const QPen pen = painter->pen();
painter->setPen(QPen(Qt::black, 1));
painter->setPen(pen);
#endif
// All paint operations need to be scaled according to
// the paint device metrics.
QwtPainter::setMetricsMap(this, painter->device());
const QwtMetricsMap &metricsMap = QwtPainter::metricsMap();
// It is almost impossible to integrate into the Qt layout
// framework, when using different fonts for printing
// and screen. To avoid writing different and Qt unconform
// layout engines we change the widget attributes, print and
// reset the widget attributes again. This way we produce a lot of
// useless layout events ...
pfilter.apply((QwtPlot *)this);
int baseLineDists[QwtPlot::axisCnt];
if ( pfilter.options() & QwtPlotPrintFilter::PrintFrameWithScales ) {
for (axisId = 0; axisId < QwtPlot::axisCnt; axisId++ ) {
QwtScaleWidget *scaleWidget = (QwtScaleWidget *)axisWidget(axisId);
if ( scaleWidget ) {
baseLineDists[axisId] = scaleWidget->margin();
scaleWidget->setMargin(0);
}
}
}
// Calculate the layout for the print.
int layoutOptions = QwtPlotLayout::IgnoreScrollbars
| QwtPlotLayout::IgnoreFrames;
if ( !(pfilter.options() & QwtPlotPrintFilter::PrintMargin) )
layoutOptions |= QwtPlotLayout::IgnoreMargin;
if ( !(pfilter.options() & QwtPlotPrintFilter::PrintLegend) )
layoutOptions |= QwtPlotLayout::IgnoreLegend;
((QwtPlot *)this)->plotLayout()->activate(this,
QwtPainter::metricsMap().deviceToLayout(plotRect),
layoutOptions);
if ((pfilter.options() & QwtPlotPrintFilter::PrintTitle)
&& (!titleLabel()->text().isEmpty())) {
printTitle(painter, plotLayout()->titleRect());
}
if ( (pfilter.options() & QwtPlotPrintFilter::PrintLegend)
&& legend() && !legend()->isEmpty() ) {
printLegend(painter, plotLayout()->legendRect());
}
for ( axisId = 0; axisId < QwtPlot::axisCnt; axisId++ ) {
QwtScaleWidget *scaleWidget = (QwtScaleWidget *)axisWidget(axisId);
if (scaleWidget) {
int baseDist = scaleWidget->margin();
int startDist, endDist;
scaleWidget->getBorderDistHint(startDist, endDist);
printScale(painter, axisId, startDist, endDist,
baseDist, plotLayout()->scaleRect(axisId));
}
}
QRect canvasRect = plotLayout()->canvasRect();
/*
The border of the bounding rect needs to ba scaled to
layout coordinates, so that it is aligned to the axes
*/
QRect boundingRect( canvasRect.left() - 1, canvasRect.top() - 1,
canvasRect.width() + 2, canvasRect.height() + 2);
boundingRect = metricsMap.layoutToDevice(boundingRect);
boundingRect.setWidth(boundingRect.width() - 1);
boundingRect.setHeight(boundingRect.height() - 1);
canvasRect = metricsMap.layoutToDevice(canvasRect);
// When using QwtPainter all sizes where computed in pixel
// coordinates and scaled by QwtPainter later. This limits
// the precision to screen resolution. A better solution
// is to scale the maps and print in unlimited resolution.
QwtScaleMap map[axisCnt];
for (axisId = 0; axisId < axisCnt; axisId++) {
map[axisId].setTransformation(axisScaleEngine(axisId)->transformation());
const QwtScaleDiv &scaleDiv = *axisScaleDiv(axisId);
map[axisId].setScaleInterval(scaleDiv.lBound(), scaleDiv.hBound());
double from, to;
if ( axisEnabled(axisId) ) {
const int sDist = axisWidget(axisId)->startBorderDist();
const int eDist = axisWidget(axisId)->endBorderDist();
const QRect &scaleRect = plotLayout()->scaleRect(axisId);
if ( axisId == xTop || axisId == xBottom ) {
from = metricsMap.layoutToDeviceX(scaleRect.left() + sDist);
to = metricsMap.layoutToDeviceX(scaleRect.right() + 1 - eDist);
} else {
from = metricsMap.layoutToDeviceY(scaleRect.bottom() + 1 - eDist );
to = metricsMap.layoutToDeviceY(scaleRect.top() + sDist);
}
} else {
int margin = plotLayout()->canvasMargin(axisId);
if ( axisId == yLeft || axisId == yRight ) {
margin = metricsMap.layoutToDeviceY(margin);
from = canvasRect.bottom() - margin;
to = canvasRect.top() + margin;
} else {
margin = metricsMap.layoutToDeviceX(margin);
from = canvasRect.left() + margin;
to = canvasRect.right() - margin;
}
}
map[axisId].setPaintXInterval(from, to);
}
// The canvas maps are already scaled.
QwtPainter::setMetricsMap(painter->device(), painter->device());
printCanvas(painter, boundingRect, canvasRect, map, pfilter);
QwtPainter::resetMetricsMap();
((QwtPlot *)this)->plotLayout()->invalidate();
// reset all widgets with their original attributes.
if ( pfilter.options() & QwtPlotPrintFilter::PrintFrameWithScales ) {
// restore the previous base line dists
for (axisId = 0; axisId < QwtPlot::axisCnt; axisId++ ) {
QwtScaleWidget *scaleWidget = (QwtScaleWidget *)axisWidget(axisId);
if ( scaleWidget )
scaleWidget->setMargin(baseLineDists[axisId]);
}
}
pfilter.reset((QwtPlot *)this);
painter->restore();
}
/*!
Paint the contents of a QwtPlot instance into a given rectangle.
\param plot Plot to be rendered
\param painter Painter
\param plotRect Bounding rectangle
\sa renderDocument(), renderTo(), QwtPainter::setRoundingAlignment()
*/
void QwtPlotRenderer::render( QwtPlot *plot,
QPainter *painter, const QRectF &plotRect ) const
{
int axisId;
if ( painter == 0 || !painter->isActive() ||
!plotRect.isValid() || plot->size().isNull() )
return;
if ( !( d_data->discardFlags & DiscardBackground ) )
qwtRenderBackground( painter, plotRect, plot );
/*
The layout engine uses the same methods as they are used
by the Qt layout system. Therefore we need to calculate the
layout in screen coordinates and paint with a scaled painter.
*/
QTransform transform;
transform.scale(
double( painter->device()->logicalDpiX() ) / plot->logicalDpiX(),
double( painter->device()->logicalDpiY() ) / plot->logicalDpiY() );
QRectF layoutRect = transform.inverted().mapRect( plotRect );
if ( !( d_data->discardFlags & DiscardBackground ) )
{
// subtract the contents margins
int left, top, right, bottom;
plot->getContentsMargins( &left, &top, &right, &bottom );
layoutRect.adjust( left, top, -right, -bottom );
}
int baseLineDists[QwtPlot::axisCnt];
if ( d_data->layoutFlags & FrameWithScales )
{
for ( axisId = 0; axisId < QwtPlot::axisCnt; axisId++ )
{
QwtScaleWidget *scaleWidget = plot->axisWidget( axisId );
if ( scaleWidget )
{
baseLineDists[axisId] = scaleWidget->margin();
scaleWidget->setMargin( 0 );
}
if ( !plot->axisEnabled( axisId ) )
{
int left = 0;
int right = 0;
int top = 0;
int bottom = 0;
// When we have a scale the frame is painted on
// the position of the backbone - otherwise we
// need to introduce a margin around the canvas
switch( axisId )
{
case QwtPlot::yLeft:
layoutRect.adjust( 1, 0, 0, 0 );
break;
case QwtPlot::yRight:
layoutRect.adjust( 0, 0, -1, 0 );
break;
case QwtPlot::xTop:
layoutRect.adjust( 0, 1, 0, 0 );
break;
case QwtPlot::xBottom:
layoutRect.adjust( 0, 0, 0, -1 );
break;
default:
break;
}
layoutRect.adjust( left, top, right, bottom );
}
}
}
// Calculate the layout for the document.
QwtPlotLayout::Options layoutOptions =
QwtPlotLayout::IgnoreScrollbars | QwtPlotLayout::IgnoreFrames;
if ( d_data->discardFlags & DiscardLegend )
layoutOptions |= QwtPlotLayout::IgnoreLegend;
plot->plotLayout()->activate( plot, layoutRect, layoutOptions );
// now start painting
painter->save();
painter->setWorldTransform( transform, true );
// canvas
QwtScaleMap maps[QwtPlot::axisCnt];
buildCanvasMaps( plot, plot->plotLayout()->canvasRect(), maps );
renderCanvas( plot, painter, plot->plotLayout()->canvasRect(), maps );
if ( !( d_data->discardFlags & DiscardTitle )
&& ( !plot->titleLabel()->text().isEmpty() ) )
{
renderTitle( plot, painter, plot->plotLayout()->titleRect() );
}
if ( !( d_data->discardFlags & DiscardLegend )
&& plot->legend() && !plot->legend()->isEmpty() )
{
renderLegend( plot, painter, plot->plotLayout()->legendRect() );
}
for ( axisId = 0; axisId < QwtPlot::axisCnt; axisId++ )
{
QwtScaleWidget *scaleWidget = plot->axisWidget( axisId );
if ( scaleWidget )
{
int baseDist = scaleWidget->margin();
int startDist, endDist;
scaleWidget->getBorderDistHint( startDist, endDist );
renderScale( plot, painter, axisId, startDist, endDist,
baseDist, plot->plotLayout()->scaleRect( axisId ) );
}
}
plot->plotLayout()->invalidate();
// reset all widgets with their original attributes.
if ( d_data->layoutFlags & FrameWithScales )
{
// restore the previous base line dists
for ( axisId = 0; axisId < QwtPlot::axisCnt; axisId++ )
{
QwtScaleWidget *scaleWidget = plot->axisWidget( axisId );
if ( scaleWidget )
scaleWidget->setMargin( baseLineDists[axisId] );
}
}
painter->restore();
}
/*!
Paint the contents of a QwtPlot instance into a given rectangle.
\param plot Plot to be rendered
\param painter Painter
\param plotRect Bounding rectangle
\sa renderDocument(), renderTo(), QwtPainter::setRoundingAlignment()
*/
void QwtPlotRenderer::render( QwtPlot *plot,
QPainter *painter, const QRectF &plotRect ) const
{
int axisId;
if ( painter == 0 || !painter->isActive() ||
!plotRect.isValid() || plot->size().isNull() )
return;
if ( !( d_data->discardFlags & DiscardBackground ) )
qwtRenderBackground( painter, plotRect, plot );
/*
The layout engine uses the same methods as they are used
by the Qt layout system. Therefore we need to calculate the
layout in screen coordinates and paint with a scaled painter.
*/
QTransform transform;
transform.scale(
double( painter->device()->logicalDpiX() ) / plot->logicalDpiX(),
double( painter->device()->logicalDpiY() ) / plot->logicalDpiY() );
painter->save();
int baseLineDists[QwtPlot::axisCnt];
if ( d_data->layoutFlags & FrameWithScales )
{
for ( axisId = 0; axisId < QwtPlot::axisCnt; axisId++ )
{
QwtScaleWidget *scaleWidget = plot->axisWidget( axisId );
if ( scaleWidget )
{
baseLineDists[axisId] = scaleWidget->margin();
scaleWidget->setMargin( 0 );
}
}
}
// Calculate the layout for the print.
QwtPlotLayout::Options layoutOptions =
QwtPlotLayout::IgnoreScrollbars | QwtPlotLayout::IgnoreFrames;
if ( d_data->discardFlags & DiscardLegend )
layoutOptions |= QwtPlotLayout::IgnoreLegend;
const QRectF layoutRect = transform.inverted().mapRect( plotRect );
plot->plotLayout()->activate( plot, layoutRect, layoutOptions );
painter->setWorldTransform( transform, true );
// canvas
QwtScaleMap maps[QwtPlot::axisCnt];
buildCanvasMaps( plot, plot->plotLayout()->canvasRect(), maps );
renderCanvas( plot, painter, plot->plotLayout()->canvasRect(), maps );
if ( !( d_data->discardFlags & DiscardTitle )
&& ( !plot->titleLabel()->text().isEmpty() ) )
{
renderTitle( plot, painter, plot->plotLayout()->titleRect() );
}
if ( !( d_data->discardFlags & DiscardLegend )
&& plot->legend() && !plot->legend()->isEmpty() )
{
renderLegend( plot, painter, plot->plotLayout()->legendRect() );
}
for ( axisId = 0; axisId < QwtPlot::axisCnt; axisId++ )
{
QwtScaleWidget *scaleWidget = plot->axisWidget( axisId );
if ( scaleWidget )
{
int baseDist = scaleWidget->margin();
int startDist, endDist;
scaleWidget->getBorderDistHint( startDist, endDist );
renderScale( plot, painter, axisId, startDist, endDist,
baseDist, plot->plotLayout()->scaleRect( axisId ) );
}
}
plot->plotLayout()->invalidate();
// reset all widgets with their original attributes.
if ( d_data->layoutFlags & FrameWithScales )
{
// restore the previous base line dists
for ( axisId = 0; axisId < QwtPlot::axisCnt; axisId++ )
{
QwtScaleWidget *scaleWidget = plot->axisWidget( axisId );
if ( scaleWidget )
scaleWidget->setMargin( baseLineDists[axisId] );
}
}
painter->restore();
}
/*!
\brief Paint the plot into a given rectangle.
Paint the contents of a QwtPlot instance into a given rectangle (Qwt modified code).
\param painter Painter
\param plotRect Bounding rectangle
\param pfilter Print filter
*/
void Plot::print(QPainter *painter, const QRect &plotRect,
const QwtPlotPrintFilter &pfilter)
{
int axisId;
if ( painter == 0 || !painter->isActive() ||
!plotRect.isValid() || size().isNull() )
return;
QwtText t = title();
printFrame(painter, plotRect);
painter->save();
// All paint operations need to be scaled according to
// the paint device metrics.
QwtPainter::setMetricsMap(this, painter->device());
const QwtMetricsMap &metricsMap = QwtPainter::metricsMap();
// It is almost impossible to integrate into the Qt layout
// framework, when using different fonts for printing
// and screen. To avoid writing different and Qt unconform
// layout engines we change the widget attributes, print and
// reset the widget attributes again. This way we produce a lot of
// useless layout events ...
pfilter.apply((QwtPlot *)this);
int baseLineDists[QwtPlot::axisCnt];
if ( !(pfilter.options() & QwtPlotPrintFilter::PrintCanvasBackground) ){
// In case of no background we set the backbone of
// the scale on the frame of the canvas.
for (axisId = 0; axisId < QwtPlot::axisCnt; axisId++ ){
QwtScaleWidget *scaleWidget = (QwtScaleWidget *)axisWidget(axisId);
if ( scaleWidget ){
baseLineDists[axisId] = scaleWidget->margin();
scaleWidget->setMargin(0);
}
}
}
// Calculate the layout for the print.
int layoutOptions = QwtPlotLayout::IgnoreScrollbars
| QwtPlotLayout::IgnoreFrames;
if ( !(pfilter.options() & QwtPlotPrintFilter::PrintMargin) )
layoutOptions |= QwtPlotLayout::IgnoreMargin;
if ( !(pfilter.options() & QwtPlotPrintFilter::PrintLegend) )
layoutOptions |= QwtPlotLayout::IgnoreLegend;
((QwtPlot *)this)->plotLayout()->activate(this,
QwtPainter::metricsMap().deviceToLayout(plotRect),
layoutOptions);
if ((pfilter.options() & QwtPlotPrintFilter::PrintTitle)
&& (!titleLabel()->text().isEmpty())){
printTitle(painter, plotLayout()->titleRect());
}
QRect canvasRect = plotLayout()->canvasRect();
for ( axisId = 0; axisId < QwtPlot::axisCnt; axisId++ ){
QwtScaleWidget *scaleWidget = (QwtScaleWidget *)axisWidget(axisId);
if (scaleWidget){
int baseDist = scaleWidget->margin();
int startDist, endDist;
scaleWidget->getBorderDistHint(startDist, endDist);
QRect scaleRect = plotLayout()->scaleRect(axisId);
if (!scaleWidget->margin()){
switch(axisId){
case xBottom:
scaleRect.translate(0, canvasRect.bottom() - scaleRect.top());
break;
case xTop:
scaleRect.translate(0, canvasRect.top() - scaleRect.bottom());
break;
case yLeft:
scaleRect.translate(canvasRect.left() - scaleRect.right(), 0);
break;
case yRight:
scaleRect.translate(canvasRect.right() - scaleRect.left(), 0);
break;
}
}
printScale(painter, axisId, startDist, endDist, baseDist, scaleRect);
}
}
if ( !(pfilter.options() & QwtPlotPrintFilter::PrintCanvasBackground) )
{
QRect boundingRect(
canvasRect.left() - 1, canvasRect.top() - 1,
canvasRect.width() + 2, canvasRect.height() + 2);
boundingRect = metricsMap.layoutToDevice(boundingRect);
boundingRect.setWidth(boundingRect.width() - 1);
boundingRect.setHeight(boundingRect.height() - 1);
painter->setPen(QPen(Qt::black));
painter->setBrush(QBrush(Qt::NoBrush));
painter->drawRect(boundingRect);
}
canvasRect = metricsMap.layoutToDevice(canvasRect);
// When using QwtPainter all sizes where computed in pixel
// coordinates and scaled by QwtPainter later. This limits
// the precision to screen resolution. A much better solution
// is to scale the maps and print in unlimited resolution.
QwtScaleMap map[axisCnt];
for (axisId = 0; axisId < axisCnt; axisId++){
map[axisId].setTransformation(axisScaleEngine(axisId)->transformation());
const QwtScaleDiv &scaleDiv = *axisScaleDiv(axisId);
map[axisId].setScaleInterval(scaleDiv.lBound(), scaleDiv.hBound());
double from, to;
if ( axisEnabled(axisId) ){
const int sDist = axisWidget(axisId)->startBorderDist();
const int eDist = axisWidget(axisId)->endBorderDist();
const QRect &scaleRect = plotLayout()->scaleRect(axisId);
if ( axisId == xTop || axisId == xBottom ){
from = metricsMap.layoutToDeviceX(scaleRect.left() + sDist);
to = metricsMap.layoutToDeviceX(scaleRect.right() + 1 - eDist);
} else {
from = metricsMap.layoutToDeviceY(scaleRect.bottom() + 1 - eDist );
to = metricsMap.layoutToDeviceY(scaleRect.top() + sDist);
}
} else {
const int margin = plotLayout()->canvasMargin(axisId);
if ( axisId == yLeft || axisId == yRight ){
from = metricsMap.layoutToDeviceX(canvasRect.bottom() - margin);
to = metricsMap.layoutToDeviceX(canvasRect.top() + margin);
} else {
from = metricsMap.layoutToDeviceY(canvasRect.left() + margin);
to = metricsMap.layoutToDeviceY(canvasRect.right() - margin);
}
}
map[axisId].setPaintXInterval(from, to);
}
// The canvas maps are already scaled.
QwtPainter::setMetricsMap(painter->device(), painter->device());
printCanvas(painter, canvasRect, map, pfilter);
QwtPainter::resetMetricsMap();
((QwtPlot *)this)->plotLayout()->invalidate();
// reset all widgets with their original attributes.
if ( !(pfilter.options() & QwtPlotPrintFilter::PrintCanvasBackground) ){
// restore the previous base line dists
for (axisId = 0; axisId < QwtPlot::axisCnt; axisId++ ){
QwtScaleWidget *scaleWidget = (QwtScaleWidget *)axisWidget(axisId);
if ( scaleWidget )
scaleWidget->setMargin(baseLineDists[axisId]);
}
}
pfilter.reset((QwtPlot *)this);
painter->restore();
setTitle(t);//hack used to avoid bug in Qwt::printTitle(): the title attributes are overwritten
}
/*!
Paint the contents of a QwtPlot instance into a given rectangle.
\param plot Plot to be rendered
\param painter Painter
\param plotRect Bounding rectangle
\sa renderDocument(), renderTo(), QwtPainter::setRoundingAlignment()
*/
void QwtPlotRenderer::render( QwtPlot *plot,
QPainter *painter, const QRectF &plotRect ) const
{
if ( painter == 0 || !painter->isActive() ||
!plotRect.isValid() || plot->size().isNull() )
{
return;
}
if ( !( d_data->discardFlags & DiscardBackground ) )
QwtPainter::drawBackgound( painter, plotRect, plot );
/*
The layout engine uses the same methods as they are used
by the Qt layout system. Therefore we need to calculate the
layout in screen coordinates and paint with a scaled painter.
*/
QTransform transform;
transform.scale(
double( painter->device()->logicalDpiX() ) / plot->logicalDpiX(),
double( painter->device()->logicalDpiY() ) / plot->logicalDpiY() );
QRectF layoutRect = transform.inverted().mapRect( plotRect );
if ( !( d_data->discardFlags & DiscardBackground ) )
{
// subtract the contents margins
int left, top, right, bottom;
plot->getContentsMargins( &left, &top, &right, &bottom );
layoutRect.adjust( left, top, -right, -bottom );
}
QwtPlotLayout *layout = plot->plotLayout();
int baseLineDists[QwtAxis::PosCount];
int canvasMargins[QwtAxis::PosCount];
for ( int axisPos = 0; axisPos < QwtAxis::PosCount; axisPos++ )
{
canvasMargins[ axisPos ] = layout->canvasMargin( axisPos );
if ( d_data->layoutFlags & FrameWithScales )
{
const QwtAxisId axisId( axisPos, QWT_DUMMY_ID );
QwtScaleWidget *scaleWidget = plot->axisWidget( axisId );
if ( scaleWidget )
{
baseLineDists[ axisPos ] = scaleWidget->margin();
scaleWidget->setMargin( 0 );
}
if ( !plot->isAxisVisible( axisId ) )
{
int left = 0;
int right = 0;
int top = 0;
int bottom = 0;
// When we have a scale the frame is painted on
// the position of the backbone - otherwise we
// need to introduce a margin around the canvas
switch( axisPos )
{
case QwtAxis::yLeft:
layoutRect.adjust( 1, 0, 0, 0 );
break;
case QwtAxis::yRight:
layoutRect.adjust( 0, 0, -1, 0 );
break;
case QwtAxis::xTop:
layoutRect.adjust( 0, 1, 0, 0 );
break;
case QwtAxis::xBottom:
layoutRect.adjust( 0, 0, 0, -1 );
break;
}
layoutRect.adjust( left, top, right, bottom );
}
}
}
// Calculate the layout for the document.
QwtPlotLayout::Options layoutOptions = QwtPlotLayout::IgnoreScrollbars;
if ( ( d_data->layoutFlags & FrameWithScales ) ||
( d_data->discardFlags & DiscardCanvasFrame ) )
{
layoutOptions |= QwtPlotLayout::IgnoreFrames;
}
if ( d_data->discardFlags & DiscardLegend )
layoutOptions |= QwtPlotLayout::IgnoreLegend;
if ( d_data->discardFlags & DiscardTitle )
layoutOptions |= QwtPlotLayout::IgnoreTitle;
if ( d_data->discardFlags & DiscardFooter )
layoutOptions |= QwtPlotLayout::IgnoreFooter;
layout->update( plot, layoutRect, layoutOptions );
// canvas
QwtScaleMapTable mapTable = buildCanvasMaps( plot, layout->canvasRect() );
if ( updateCanvasMargins( plot, layout->canvasRect(), mapTable ) )
{
// recalculate maps and layout, when the margins
// have been changed
layout->update( plot, layoutRect, layoutOptions );
mapTable = buildCanvasMaps( plot, layout->canvasRect() );
}
// now start painting
painter->save();
painter->setWorldTransform( transform, true );
renderCanvas( plot, painter, layout->canvasRect(), mapTable );
if ( !( d_data->discardFlags & DiscardTitle )
&& ( !plot->titleLabel()->text().isEmpty() ) )
{
renderTitle( plot, painter, layout->titleRect() );
}
if ( !( d_data->discardFlags & DiscardFooter )
&& ( !plot->footerLabel()->text().isEmpty() ) )
{
renderFooter( plot, painter, layout->footerRect() );
}
if ( !( d_data->discardFlags & DiscardLegend )
&& plot->legend() && !plot->legend()->isEmpty() )
{
renderLegend( plot, painter, layout->legendRect() );
}
for ( int axisPos = 0; axisPos < QwtAxis::PosCount; axisPos++ )
{
for ( int i = 0; i < plot->axesCount( i ); i++ )
{
const QwtAxisId axisId( axisPos, i );
QwtScaleWidget *scaleWidget = plot->axisWidget( axisId );
if ( scaleWidget )
{
int baseDist = scaleWidget->margin();
int startDist, endDist;
scaleWidget->getBorderDistHint( startDist, endDist );
renderScale( plot, painter, axisId, startDist, endDist,
baseDist, layout->scaleRect( axisId ) );
}
}
}
painter->restore();
// restore all setting to their original attributes.
for ( int axisPos = 0; axisPos < QwtAxis::PosCount; axisPos++ )
{
if ( d_data->layoutFlags & FrameWithScales )
{
const QwtAxisId axisId( axisPos, QWT_DUMMY_ID );
QwtScaleWidget *scaleWidget = plot->axisWidget( axisId );
if ( scaleWidget )
scaleWidget->setMargin( baseLineDists[axisPos] );
}
layout->setCanvasMargin( canvasMargins[axisPos] );
}
layout->invalidate();
}
/** Initialisation method. Sets up all widgets and variables not done in the constructor.
*
*/
void AxisDetails::initWidgets()
{
if (m_initialised)
{
return;
}
else
{
Plot *p = m_graph->plotWidget();
int style = (int) m_graph->axisType(m_mappedaxis);
bool axisOn = p->axisEnabled(m_mappedaxis);
const QList<int> majTicks = p->getMajorTicksType();
const QList<int> minTicks = p->getMinorTicksType();
const QwtScaleDraw *sd = p->axisScaleDraw(m_mappedaxis);
bool labelsOn = sd->hasComponent(QwtAbstractScaleDraw::Labels);
int format = p->axisLabelFormat(m_mappedaxis);
//Top
m_chkShowAxis->setChecked(axisOn);
m_txtTitle->setText(m_graph->axisTitle(m_mappedaxis));
m_labelFont = m_graph->axisTitleFont(m_mappedaxis);
//bottom left
m_cmbAxisType->setCurrentIndex(style);
setAxisFormatOptions(style);
m_scaleFont = p->axisFont(m_mappedaxis);
m_cbtnAxisColor->setColor(m_graph->axisColor(m_mappedaxis));
m_cmbMajorTicksType->setCurrentIndex(majTicks[m_mappedaxis]);
m_cmbMinorTicksType->setCurrentIndex(minTicks[m_mappedaxis]);
QwtScaleWidget *scale = dynamic_cast<QwtScaleWidget *>(p->axisWidget(m_mappedaxis));
if (scale)
{
m_spnBaseline->setValue(scale->margin());
}
else
{
m_spnBaseline->setValue(0);
}
//bottom right
m_grpShowLabels->setChecked(labelsOn);
m_cmbFormat->setEnabled(labelsOn && axisOn);
m_cmbFormat->setCurrentIndex(format);
if (m_cmbAxisType->currentIndex() == ScaleDraw::Numeric)
{
m_spnPrecision->setValue(p->axisLabelPrecision(m_mappedaxis));
}
else if (m_cmbAxisType->currentIndex() == ScaleDraw::Text)
{
m_cmbColName->setCurrentText(m_graph->axisFormatInfo(m_mappedaxis));
}
m_spnPrecision->setEnabled(format != 0);
if (m_mappedaxis == QwtPlot::xBottom || m_mappedaxis == QwtPlot::xTop)
{
m_spnAngle->setEnabled(labelsOn && axisOn);
m_spnAngle->setValue(m_graph->labelsRotation(m_mappedaxis));
}
else
{
m_spnAngle->setEnabled(false);
m_spnAngle->setValue(0);
}
m_cbtnAxisNumColor->setColor(m_graph->axisLabelsColor(m_mappedaxis));
QString formula = m_graph->axisFormula(m_mappedaxis);
m_txtFormula->setFixedWidth(150);
if (!formula.isEmpty())
{
m_chkShowFormula->setChecked(true);
m_txtFormula->setEnabled(true);
m_txtFormula->setText(formula);
}
else
{
m_chkShowFormula->setChecked(false);
m_txtFormula->setEnabled(false);
}
showAxis();
connect(m_chkShowFormula, SIGNAL(stateChanged(int)), this, SLOT(setModified()));
connect(m_chkShowAxis, SIGNAL(stateChanged(int)), this, SLOT(setModified()));
connect(m_cmbAxisType, SIGNAL(currentIndexChanged(int)), this, SLOT(setModified()));
connect(m_cmbAxisType, SIGNAL(editTextChanged(QString)), this, SLOT(setModified()));
connect(m_cmbMajorTicksType, SIGNAL(currentIndexChanged(int)), this, SLOT(setModified()));
connect(m_cmbMajorTicksType, SIGNAL(editTextChanged(QString)), this, SLOT(setModified()));
connect(m_cmbTableName, SIGNAL(currentIndexChanged(int)), this, SLOT(setModified()));
connect(m_cmbTableName, SIGNAL(editTextChanged(QString)), this, SLOT(setModified()));
connect(m_cmbMinorTicksType, SIGNAL(currentIndexChanged(int)), this, SLOT(setModified()));
connect(m_cmbMinorTicksType, SIGNAL(editTextChanged(QString)), this, SLOT(setModified()));
connect(m_cmbColName, SIGNAL(currentIndexChanged(int)), this, SLOT(setModified()));
connect(m_cmbColName, SIGNAL(editTextChanged(QString)), this, SLOT(setModified()));
connect(m_cmbFormat, SIGNAL(currentIndexChanged(int)), this, SLOT(setModified()));
connect(m_cmbFormat, SIGNAL(editTextChanged(QString)), this, SLOT(setModified()));
connect(m_grpShowLabels, SIGNAL(clicked(bool)), this, SLOT(setModified()));
connect(m_btnAxesFont, SIGNAL(clicked()), this, SLOT(setModified()));
connect(m_btnLabelFont, SIGNAL(clicked()), this, SLOT(setModified()));
connect(m_txtFormula, SIGNAL(textChanged()), this, SLOT(setModified()));
connect(m_txtTitle, SIGNAL(textChanged()), this, SLOT(setModified()));
connect(m_formatButtons, SIGNAL(formattingModified()), this, SLOT(setModified()));
connect(m_spnPrecision,SIGNAL(valueChanged(int)), this, SLOT(setModified()));
connect(m_spnAngle,SIGNAL(valueChanged(int)), this, SLOT(setModified()));
connect(m_spnBaseline,SIGNAL(valueChanged(int)), this, SLOT(setModified()));
connect(m_cbtnAxisColor, SIGNAL(colorChanged()), this, SLOT(setModified()));
connect(m_cbtnAxisNumColor, SIGNAL(colorChanged()), this, SLOT(setModified()));
m_modified = false;
m_initialised = true;
}
}
