qwt_plot_renderer.cpp

/******************************************************************************
 * Qwt Widget Library
 * Copyright (C) 1997   Josef Wilgen
 * Copyright (C) 2002   Uwe Rathmann
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the Qwt License, Version 1.0
 *****************************************************************************/
 
#include "qwt_plot_renderer.h"
#include "qwt_plot.h"
#include "qwt_painter.h"
#include "qwt_plot_layout.h"
#include "qwt_abstract_legend.h"
#include "qwt_scale_widget.h"
#include "qwt_scale_engine.h"
#include "qwt_scale_map.h"
#include "qwt_text.h"
#include "qwt_text_label.h"
#include "qwt_math.h"
 
#include <qpainter.h>
#include <qpainterpath.h>
#include <qtransform.h>
#include <qprinter.h>
#include <qfiledialog.h>
#include <qfileinfo.h>
#include <qimagewriter.h>
#include <qvariant.h>
#include <qmargins.h>
 
#ifndef QWT_NO_SVG
#ifdef QT_SVG_LIB
#define QWT_FORMAT_SVG 1
#endif
#endif
 
#ifndef QT_NO_PRINTER
#define QWT_FORMAT_PDF 1
#endif
 
#ifndef QT_NO_PDF
 
// QPdfWriter::setResolution() has been introduced with
// Qt 5.3. Guess it is o.k. to stay with QPrinter for older
// versions.
 
#if QT_VERSION >= 0x050300
 
#ifndef QWT_FORMAT_PDF
#define QWT_FORMAT_PDF 1
#endif
 
#define QWT_PDF_WRITER 1
 
#endif
#endif
 
#ifndef QT_NO_PRINTER
// postscript support has been dropped in Qt5
#if QT_VERSION < 0x050000
#define QWT_FORMAT_POSTSCRIPT 1
#endif
#endif
 
#if QWT_FORMAT_SVG
#include <qsvggenerator.h>
#endif
 
#if QWT_PDF_WRITER
#include <qpdfwriter.h>
#endif
 
static qreal qwtScalePenWidth( const QwtPlot* plot )
{
    qreal pw = 0.0;
 
    for ( int axisId = 0; axisId < QwtAxis::AxisPositions; axisId++ )
    {
        if ( plot->isAxisVisible( axisId ) )
            pw = qMax( pw, plot->axisScaleDraw( axisId )->penWidthF() );
    }
 
    return pw;
}
 
static QColor qwtScalePenColor( const QwtPlot* plot )
{
    const QPalette pal = plot->axisWidget( QwtAxis::YLeft )->palette();
    return pal.color( QPalette::WindowText );
}
 
static QPainterPath qwtCanvasClip(
    const QWidget* canvas, const QRectF& canvasRect )
{
    // The clip region is calculated in integers
    // To avoid too much rounding errors better
    // calculate it in target device resolution
 
    int x1 = qwtCeil( canvasRect.left() );
    int x2 = qwtFloor( canvasRect.right() );
    int y1 = qwtCeil( canvasRect.top() );
    int y2 = qwtFloor( canvasRect.bottom() );
 
    const QRect r( x1, y1, x2 - x1 - 1, y2 - y1 - 1 );
 
    QPainterPath clipPath;
 
    ( void ) QMetaObject::invokeMethod(
        const_cast< QWidget* >( canvas ), "borderPath",
        Qt::DirectConnection,
        Q_RETURN_ARG( QPainterPath, clipPath ), Q_ARG( QRect, r ) );
 
    return clipPath;
}
 
static inline QFont qwtResolvedFont( const QWidget* widget )
{
    QFont font = widget->font();
#if QT_VERSION >= 0x060000
    font.setResolveMask( QFont::AllPropertiesResolved );
#else
    font.resolve( QFont::AllPropertiesResolved );
#endif
 
    return font;
}
 
class QwtPlotRenderer::PrivateData
{
  public:
    PrivateData()
        : discardFlags( QwtPlotRenderer::DiscardNone )
        , layoutFlags( QwtPlotRenderer::DefaultLayout )
    {
    }
 
    QwtPlotRenderer::DiscardFlags discardFlags;
    QwtPlotRenderer::LayoutFlags layoutFlags;
};
 
QwtPlotRenderer::QwtPlotRenderer( QObject* parent )
    : QObject( parent )
{
    m_data = new PrivateData;
}
 
QwtPlotRenderer::~QwtPlotRenderer()
{
    delete m_data;
}
 
void QwtPlotRenderer::setDiscardFlag( DiscardFlag flag, bool on )
{
    if ( on )
        m_data->discardFlags |= flag;
    else
        m_data->discardFlags &= ~flag;
}
 
bool QwtPlotRenderer::testDiscardFlag( DiscardFlag flag ) const
{
    return m_data->discardFlags & flag;
}
 
void QwtPlotRenderer::setDiscardFlags( DiscardFlags flags )
{
    m_data->discardFlags = flags;
}
 
QwtPlotRenderer::DiscardFlags QwtPlotRenderer::discardFlags() const
{
    return m_data->discardFlags;
}
 
void QwtPlotRenderer::setLayoutFlag( LayoutFlag flag, bool on )
{
    if ( on )
        m_data->layoutFlags |= flag;
    else
        m_data->layoutFlags &= ~flag;
}
 
bool QwtPlotRenderer::testLayoutFlag( LayoutFlag flag ) const
{
    return m_data->layoutFlags & flag;
}
 
void QwtPlotRenderer::setLayoutFlags( LayoutFlags flags )
{
    m_data->layoutFlags = flags;
}
 
QwtPlotRenderer::LayoutFlags QwtPlotRenderer::layoutFlags() const
{
    return m_data->layoutFlags;
}
 
void QwtPlotRenderer::renderDocument( QwtPlot* plot,
    const QString& fileName, const QSizeF& sizeMM, int resolution )
{
    renderDocument( plot, fileName,
        QFileInfo( fileName ).suffix(), sizeMM, resolution );
}
 
void QwtPlotRenderer::renderDocument( QwtPlot* plot,
    const QString& fileName, const QString& format,
    const QSizeF& sizeMM, int resolution )
{
    if ( plot == NULL || sizeMM.isEmpty() || resolution <= 0 )
        return;
 
    QString title = plot->title().text();
    if ( title.isEmpty() )
        title = "Plot Document";
 
    const double mmToInch = 1.0 / 25.4;
    const QSizeF size = sizeMM * mmToInch * resolution;
 
    const QRectF documentRect( 0.0, 0.0, size.width(), size.height() );
 
    const QString fmt = format.toLower();
    if ( fmt == QLatin1String( "pdf" ) )
    {
#if QWT_FORMAT_PDF
 
#if QWT_PDF_WRITER
        QPdfWriter pdfWriter( fileName );
        pdfWriter.setPageSize( QPageSize( sizeMM, QPageSize::Millimeter ) );
        pdfWriter.setTitle( title );
        pdfWriter.setPageMargins( QMarginsF() );
        pdfWriter.setResolution( resolution );
 
        QPainter painter( &pdfWriter );
        render( plot, &painter, documentRect );
#else
        QPrinter printer;
        printer.setOutputFormat( QPrinter::PdfFormat );
        printer.setColorMode( QPrinter::Color );
        printer.setFullPage( true );
        printer.setPaperSize( sizeMM, QPrinter::Millimeter );
        printer.setDocName( title );
        printer.setOutputFileName( fileName );
        printer.setResolution( resolution );
 
        QPainter painter( &printer );
        render( plot, &painter, documentRect );
#endif
#endif
    }
    else if ( fmt == QLatin1String( "ps" ) )
    {
#if QWT_FORMAT_POSTSCRIPT
        QPrinter printer;
        printer.setOutputFormat( QPrinter::PostScriptFormat );
        printer.setColorMode( QPrinter::Color );
        printer.setFullPage( true );
        printer.setPaperSize( sizeMM, QPrinter::Millimeter );
        printer.setDocName( title );
        printer.setOutputFileName( fileName );
        printer.setResolution( resolution );
 
        QPainter painter( &printer );
        render( plot, &painter, documentRect );
#endif
    }
    else if ( fmt == QLatin1String( "svg" ) )
    {
#if QWT_FORMAT_SVG
        QSvgGenerator generator;
        generator.setTitle( title );
        generator.setFileName( fileName );
        generator.setResolution( resolution );
        generator.setViewBox( documentRect );
 
        QPainter painter( &generator );
        render( plot, &painter, documentRect );
#endif
    }
    else
    {
        if ( QImageWriter::supportedImageFormats().indexOf(
            format.toLatin1() ) >= 0 )
        {
            const QRect imageRect = documentRect.toRect();
            const int dotsPerMeter = qRound( resolution * mmToInch * 1000.0 );
 
            QImage image( imageRect.size(), QImage::Format_ARGB32 );
            image.setDotsPerMeterX( dotsPerMeter );
            image.setDotsPerMeterY( dotsPerMeter );
            image.fill( QColor( Qt::white ).rgb() );
 
            QPainter painter( &image );
            render( plot, &painter, imageRect );
            painter.end();
 
            image.save( fileName, format.toLatin1() );
        }
    }
}
 
void QwtPlotRenderer::renderTo(
    QwtPlot* plot, QPaintDevice& paintDevice ) const
{
    int w = paintDevice.width();
    int h = paintDevice.height();
 
    QPainter p( &paintDevice );
    render( plot, &p, QRectF( 0, 0, w, h ) );
}
 
#ifndef QT_NO_PRINTER
 
void QwtPlotRenderer::renderTo(
    QwtPlot* plot, QPrinter& printer ) const
{
    int w = printer.width();
    int h = printer.height();
 
    QRectF rect( 0, 0, w, h );
    double aspect = rect.width() / rect.height();
    if ( ( aspect < 1.0 ) )
        rect.setHeight( aspect * rect.width() );
 
    QPainter p( &printer );
    render( plot, &p, rect );
}
 
#endif
 
#if QWT_FORMAT_SVG
 
void QwtPlotRenderer::renderTo(
    QwtPlot* plot, QSvgGenerator& generator ) const
{
    QRectF rect = generator.viewBoxF();
    if ( rect.isEmpty() )
        rect.setRect( 0, 0, generator.width(), generator.height() );
 
    if ( rect.isEmpty() )
        rect.setRect( 0, 0, 800, 600 ); // something
 
    QPainter p( &generator );
    render( plot, &p, rect );
}
 
#endif
 
void QwtPlotRenderer::render( QwtPlot* plot,
    QPainter* painter, const QRectF& plotRect ) const
{
    if ( painter == 0 || !painter->isActive() ||
        !plotRect.isValid() || plot->size().isNull() )
    {
        return;
    }
 
    if ( !( m_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 ( !( m_data->discardFlags & DiscardBackground ) )
    {
        // subtract the contents margins
 
        const QMargins m = plot->contentsMargins();
        layoutRect.adjust( m.left(), m.top(), -m.right(), -m.bottom() );
    }
 
    QwtPlotLayout* layout = plot->plotLayout();
 
    int baseLineDists[QwtAxis::AxisPositions];
    int canvasMargins[QwtAxis::AxisPositions];
 
    for ( int axisPos = 0; axisPos < QwtAxis::AxisPositions; axisPos++ )
    {
        canvasMargins[axisPos] = layout->canvasMargin( axisPos );
 
        if ( m_data->layoutFlags & FrameWithScales )
        {
            const QwtAxisId axisId( axisPos );
 
            QwtScaleWidget* scaleWidget = plot->axisWidget( axisId );
            if ( scaleWidget )
            {
                baseLineDists[axisPos] = scaleWidget->margin();
                scaleWidget->setMargin( 0 );
            }
 
            if ( !plot->isAxisVisible( axisId ) )
            {
                // 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
 
                const qreal fw = qwtScalePenWidth( plot );
 
                switch( axisPos )
                {
                    case QwtAxis::YLeft:
                        layoutRect.adjust( fw, 0, 0, 0 );
                        break;
 
                    case QwtAxis::YRight:
                        layoutRect.adjust( 0, 0, -fw, 0 );
                        break;
 
                    case QwtAxis::XTop:
                        layoutRect.adjust( 0, fw, 0, 0 );
                        break;
 
                    case QwtAxis::XBottom:
                        layoutRect.adjust( 0, 0, 0, -fw );
                        break;
 
                    default:
                        ;
                }
            }
        }
    }
 
    // Calculate the layout for the document.
 
    QwtPlotLayout::Options layoutOptions = QwtPlotLayout::IgnoreScrollbars;
 
    if ( ( m_data->layoutFlags & FrameWithScales ) ||
        ( m_data->discardFlags & DiscardCanvasFrame ) )
    {
        layoutOptions |= QwtPlotLayout::IgnoreFrames;
    }
 
    if ( m_data->discardFlags & DiscardLegend )
        layoutOptions |= QwtPlotLayout::IgnoreLegend;
 
    if ( m_data->discardFlags & DiscardTitle )
        layoutOptions |= QwtPlotLayout::IgnoreTitle;
 
    if ( m_data->discardFlags & DiscardFooter )
        layoutOptions |= QwtPlotLayout::IgnoreFooter;
 
    layout->activate( plot, layoutRect, layoutOptions );
 
    // canvas
 
    QwtScaleMap maps[QwtAxis::AxisPositions];
    buildCanvasMaps( plot, layout->canvasRect(), maps );
    if ( updateCanvasMargins( plot, layout->canvasRect(), maps ) )
    {
        // recalculate maps and layout, when the margins
        // have been changed
 
        layout->activate( plot, layoutRect, layoutOptions );
        buildCanvasMaps( plot, layout->canvasRect(), maps );
    }
 
    // now start painting
 
    painter->save();
    painter->setWorldTransform( transform, true );
 
    renderCanvas( plot, painter, layout->canvasRect(), maps );
 
    if ( !( m_data->discardFlags & DiscardTitle )
        && ( !plot->titleLabel()->text().isEmpty() ) )
    {
        renderTitle( plot, painter, layout->titleRect() );
    }
 
    if ( !( m_data->discardFlags & DiscardFooter )
        && ( !plot->footerLabel()->text().isEmpty() ) )
    {
        renderFooter( plot, painter, layout->footerRect() );
    }
 
    if ( !( m_data->discardFlags & DiscardLegend )
        && plot->legend() && !plot->legend()->isEmpty() )
    {
        renderLegend( plot, painter, layout->legendRect() );
    }
 
    for ( int axisPos = 0; axisPos < QwtAxis::AxisPositions; axisPos++ )
    {
        {
            const QwtAxisId axisId( axisPos );
 
            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::AxisPositions; axisPos++ )
    {
        if ( m_data->layoutFlags & FrameWithScales )
        {
            const QwtAxisId axisId( axisPos );
 
            QwtScaleWidget* scaleWidget = plot->axisWidget( axisId );
            if ( scaleWidget  )
                scaleWidget->setMargin( baseLineDists[axisPos] );
        }
 
        layout->setCanvasMargin( canvasMargins[axisPos] );
    }
 
    layout->invalidate();
 
}
 
void QwtPlotRenderer::renderTitle( const QwtPlot* plot,
    QPainter* painter, const QRectF& titleRect ) const
{
    painter->setFont( qwtResolvedFont( plot->titleLabel() ) );
 
    const QColor color = plot->titleLabel()->palette().color(
        QPalette::Active, QPalette::Text );
 
    painter->setPen( color );
    plot->titleLabel()->text().draw( painter, titleRect );
}
 
void QwtPlotRenderer::renderFooter( const QwtPlot* plot,
    QPainter* painter, const QRectF& footerRect ) const
{
    painter->setFont( qwtResolvedFont( plot->footerLabel() ) );
 
    const QColor color = plot->footerLabel()->palette().color(
        QPalette::Active, QPalette::Text );
 
    painter->setPen( color );
    plot->footerLabel()->text().draw( painter, footerRect );
}
 
void QwtPlotRenderer::renderLegend( const QwtPlot* plot,
    QPainter* painter, const QRectF& legendRect ) const
{
    if ( plot->legend() )
    {
        bool fillBackground = !( m_data->discardFlags & DiscardBackground );
        plot->legend()->renderLegend( painter, legendRect, fillBackground );
    }
}
 
void QwtPlotRenderer::renderScale( const QwtPlot* plot, QPainter* painter,
    QwtAxisId axisId, int startDist, int endDist, int baseDist,
    const QRectF& scaleRect ) const
{
    if ( !plot->isAxisVisible( axisId ) )
        return;
 
    const QwtScaleWidget* scaleWidget = plot->axisWidget( axisId );
    if ( scaleWidget->isColorBarEnabled()
        && scaleWidget->colorBarWidth() > 0 )
    {
        scaleWidget->drawColorBar( painter, scaleWidget->colorBarRect( scaleRect ) );
        baseDist += scaleWidget->colorBarWidth() + scaleWidget->spacing();
    }
 
    painter->save();
 
    QwtScaleDraw::Alignment align;
    double x, y, w;
 
    qreal off = 0.0;
    if ( m_data->layoutFlags & FrameWithScales )
        off = qwtScalePenWidth( plot );
 
    switch ( axisId )
    {
        case QwtAxis::YLeft:
        {
            x = scaleRect.right() - 1.0 - baseDist - off;
            y = scaleRect.y() + startDist;
            w = scaleRect.height() - startDist - endDist;
            align = QwtScaleDraw::LeftScale;
            break;
        }
        case QwtAxis::YRight:
        {
            x = scaleRect.left() + baseDist + off;
            y = scaleRect.y() + startDist;
            w = scaleRect.height() - startDist - endDist;
            align = QwtScaleDraw::RightScale;
            break;
        }
        case QwtAxis::XTop:
        {
            x = scaleRect.left() + startDist;
            y = scaleRect.bottom() - 1.0 - baseDist - off;
            w = scaleRect.width() - startDist - endDist;
            align = QwtScaleDraw::TopScale;
            break;
        }
        case QwtAxis::XBottom:
        {
            x = scaleRect.left() + startDist;
            y = scaleRect.top() + baseDist + off;
            w = scaleRect.width() - startDist - endDist;
            align = QwtScaleDraw::BottomScale;
            break;
        }
        default:
            return;
    }
 
    scaleWidget->drawTitle( painter, align, scaleRect );
 
    painter->setFont( qwtResolvedFont( scaleWidget ) );
 
    QwtScaleDraw* sd = const_cast< QwtScaleDraw* >( scaleWidget->scaleDraw() );
    const QPointF sdPos = sd->pos();
    const double sdLength = sd->length();
 
    const bool hasBackbone = sd->hasComponent( QwtAbstractScaleDraw::Backbone );
 
    if ( m_data->layoutFlags & FrameWithScales )
        sd->enableComponent( QwtAbstractScaleDraw::Backbone, false );
 
    sd->move( x, y );
    sd->setLength( w );
 
    QPalette palette = scaleWidget->palette();
    palette.setCurrentColorGroup( QPalette::Active );
    sd->draw( painter, palette );
 
    // reset previous values
    sd->move( sdPos );
    sd->setLength( sdLength );
    sd->enableComponent( QwtAbstractScaleDraw::Backbone, hasBackbone );
 
    painter->restore();
}
 
void QwtPlotRenderer::renderCanvas( const QwtPlot* plot,
    QPainter* painter, const QRectF& canvasRect,
    const QwtScaleMap* maps ) const
{
    const QWidget* canvas = plot->canvas();
 
    QRectF r = canvasRect.adjusted( 0.0, 0.0, -1.0, -1.0 );
 
    if ( m_data->layoutFlags & FrameWithScales )
    {
        painter->save();
 
        QPen pen;
        pen.setColor( qwtScalePenColor( plot ) );
        pen.setWidth( qwtScalePenWidth( plot ) );
        pen.setJoinStyle( Qt::MiterJoin );
 
        painter->setPen( pen );
 
        const qreal pw2 = 0.5 * pen.widthF();
        r.adjust( -pw2, -pw2, pw2, pw2 );
 
        if ( !( m_data->discardFlags & DiscardCanvasBackground ) )
        {
            const QBrush bgBrush =
                canvas->palette().brush( plot->backgroundRole() );
            painter->setBrush( bgBrush );
        }
 
        QwtPainter::drawRect( painter, r );
 
        painter->restore();
        painter->save();
 
        painter->setClipRect( canvasRect );
        plot->drawItems( painter, canvasRect, maps );
 
        painter->restore();
    }
    else if ( canvas->testAttribute( Qt::WA_StyledBackground ) )
    {
        QPainterPath clipPath;
 
        painter->save();
 
        if ( !( m_data->discardFlags & DiscardCanvasBackground ) )
        {
            QwtPainter::drawBackgound( painter, r, canvas );
            clipPath = qwtCanvasClip( canvas, canvasRect );
        }
 
        painter->restore();
        painter->save();
 
        if ( clipPath.isEmpty() )
            painter->setClipRect( canvasRect );
        else
            painter->setClipPath( clipPath );
 
        plot->drawItems( painter, canvasRect, maps );
 
        painter->restore();
    }
    else
    {
        QPainterPath clipPath;
 
        double frameWidth = 0.0;
 
        if ( !( m_data->discardFlags & DiscardCanvasFrame ) )
        {
            const QVariant fw = canvas->property( "frameWidth" );
            if ( fw.canConvert< double >() )
                frameWidth = fw.value< double >();
 
            clipPath = qwtCanvasClip( canvas, canvasRect );
        }
 
        QRectF innerRect = canvasRect.adjusted(
            frameWidth, frameWidth, -frameWidth, -frameWidth );
 
        painter->save();
 
        if ( clipPath.isEmpty() )
        {
            painter->setClipRect( innerRect );
        }
        else
        {
            painter->setClipPath( clipPath );
        }
 
        if ( !( m_data->discardFlags & DiscardCanvasBackground ) )
        {
            QwtPainter::drawBackgound( painter, innerRect, canvas );
        }
 
        plot->drawItems( painter, innerRect, maps );
 
        painter->restore();
 
        if ( frameWidth > 0 )
        {
            painter->save();
 
            const int frameStyle =
                canvas->property( "frameShadow" ).toInt() |
                canvas->property( "frameShape" ).toInt();
 
            const QVariant borderRadius = canvas->property( "borderRadius" );
            if ( borderRadius.canConvert< double >()
                && borderRadius.value< double >() > 0.0 )
            {
                const double radius = borderRadius.value< double >();
 
                QwtPainter::drawRoundedFrame( painter, canvasRect,
                    radius, radius, canvas->palette(), frameWidth, frameStyle );
            }
            else
            {
                const int midLineWidth = canvas->property( "midLineWidth" ).toInt();
 
                QwtPainter::drawFrame( painter, canvasRect,
                    canvas->palette(), canvas->foregroundRole(),
                    frameWidth, midLineWidth, frameStyle );
            }
            painter->restore();
        }
    }
}
 
void QwtPlotRenderer::buildCanvasMaps( const QwtPlot* plot,
    const QRectF& canvasRect, QwtScaleMap maps[] ) const
{
    for ( int axisPos = 0; axisPos < QwtAxis::AxisPositions; axisPos++ )
    {
        {
            const QwtAxisId axisId( axisPos );
 
            QwtScaleMap& scaleMap = maps[axisId];
 
            scaleMap.setTransformation(
                plot->axisScaleEngine( axisId )->transformation() );
 
            const QwtScaleDiv& scaleDiv = plot->axisScaleDiv( axisId );
            scaleMap.setScaleInterval(
                scaleDiv.lowerBound(), scaleDiv.upperBound() );
 
            double from, to;
            if ( plot->isAxisVisible( axisId ) )
            {
                const int sDist = plot->axisWidget( axisId )->startBorderDist();
                const int eDist = plot->axisWidget( axisId )->endBorderDist();
                const QRectF scaleRect = plot->plotLayout()->scaleRect( axisId );
 
                if ( QwtAxis::isXAxis( axisPos ) )
                {
                    from = scaleRect.left() + sDist;
                    to = scaleRect.right() - eDist;
                }
                else
                {
                    from = scaleRect.bottom() - eDist;
                    to = scaleRect.top() + sDist;
                }
            }
            else
            {
                int margin = 0;
                if ( !plot->plotLayout()->alignCanvasToScale( axisPos ) )
                    margin = plot->plotLayout()->canvasMargin( axisPos );
 
                if ( QwtAxis::isYAxis( axisPos ) )
                {
                    from = canvasRect.bottom() - margin;
                    to = canvasRect.top() + margin;
                }
                else
                {
                    from = canvasRect.left() + margin;
                    to = canvasRect.right() - margin;
                }
            }
            scaleMap.setPaintInterval( from, to );
        }
    }
}
 
bool QwtPlotRenderer::updateCanvasMargins( QwtPlot* plot,
    const QRectF& canvasRect, const QwtScaleMap maps[] ) const
{
    using namespace QwtAxis;
 
    double margins[AxisPositions];
    plot->getCanvasMarginsHint( maps, canvasRect,
        margins[YLeft], margins[XTop], margins[YRight], margins[XBottom] );
 
    bool marginsChanged = false;
    for ( int axisId = 0; axisId < AxisPositions; axisId++ )
    {
        if ( margins[axisId] >= 0.0 )
        {
            const int m = qwtCeil( margins[axisId] );
            plot->plotLayout()->setCanvasMargin( m, axisId);
            marginsChanged = true;
        }
    }
 
    return marginsChanged;
}
 
bool QwtPlotRenderer::exportTo( QwtPlot* plot, const QString& documentName,
    const QSizeF& sizeMM, int resolution )
{
    if ( plot == NULL )
        return false;
 
    QString fileName = documentName;
 
    // What about translation
 
#ifndef QT_NO_FILEDIALOG
    const QList< QByteArray > imageFormats =
        QImageWriter::supportedImageFormats();
 
    QStringList filter;
#if QWT_FORMAT_PDF
    filter += QString( "PDF " ) + tr( "Documents" ) + " (*.pdf)";
#endif
#if QWT_FORMAT_SVG
    filter += QString( "SVG " ) + tr( "Documents" ) + " (*.svg)";
#endif
#if QWT_FORMAT_POSTSCRIPT
    filter += QString( "Postscript " ) + tr( "Documents" ) + " (*.ps)";
#endif
 
    if ( imageFormats.size() > 0 )
    {
        QString imageFilter( tr( "Images" ) );
        imageFilter += " (";
        for ( int i = 0; i < imageFormats.size(); i++ )
        {
            if ( i > 0 )
                imageFilter += " ";
            imageFilter += "*.";
            imageFilter += imageFormats[i];
        }
        imageFilter += ")";
 
        filter += imageFilter;
    }
 
    fileName = QFileDialog::getSaveFileName(
        NULL, tr( "Export File Name" ), fileName,
        filter.join( ";;" ), NULL, QFileDialog::DontConfirmOverwrite );
#endif
    if ( fileName.isEmpty() )
        return false;
 
    renderDocument( plot, fileName, sizeMM, resolution );
 
    return true;
}
 
#include "moc_qwt_plot_renderer.cpp"