10 #include "qwt_plot_panner.h" 
   11 #include "qwt_scale_div.h" 
   13 #include "qwt_scale_map.h" 
   14 #include "qwt_painter.h" 
   18 #include <qstyleoption.h> 
   20 #include <qpainterpath.h> 
   22 static QBitmap qwtBorderMask( 
const QWidget* canvas, 
const QSize& size )
 
   24 #if QT_VERSION >= 0x050000 
   28     const QRect r( 0, 0, size.width(), size.height() );
 
   30     QPainterPath borderPath;
 
   32     ( void )QMetaObject::invokeMethod(
 
   33         const_cast< QWidget* 
>( canvas ), 
"borderPath", Qt::DirectConnection,
 
   34         Q_RETURN_ARG( QPainterPath, borderPath ), Q_ARG( QRect, r ) );
 
   36     if ( borderPath.isEmpty() )
 
   38         if ( canvas->contentsRect() == canvas->rect() )
 
   41 #if QT_VERSION >= 0x050000 
   42         QBitmap mask( size* pixelRatio );
 
   43         mask.setDevicePixelRatio( pixelRatio );
 
   47         mask.fill( Qt::color0 );
 
   49         QPainter painter( &mask );
 
   50         painter.fillRect( canvas->contentsRect(), Qt::color1 );
 
   55 #if QT_VERSION >= 0x050000 
   56     QImage image( size* pixelRatio, QImage::Format_ARGB32_Premultiplied );
 
   57     image.setDevicePixelRatio( pixelRatio );
 
   59     QImage image( size, QImage::Format_ARGB32_Premultiplied );
 
   61     image.fill( Qt::color0 );
 
   63     QPainter painter( &image );
 
   64     painter.setClipPath( borderPath );
 
   65     painter.fillRect( r, Qt::color1 );
 
   69     painter.setCompositionMode( QPainter::CompositionMode_DestinationOut );
 
   71     if ( canvas->testAttribute(Qt::WA_StyledBackground ) )
 
   73         QStyleOptionFrame opt;
 
   76         canvas->style()->drawPrimitive( QStyle::PE_Frame, &opt, &painter, canvas );
 
   80         const QVariant borderRadius = canvas->property( 
"borderRadius" );
 
   81         const QVariant frameWidth = canvas->property( 
"frameWidth" );
 
   83         if ( borderRadius.canConvert< 
double >() && frameWidth.canConvert< 
int >() )
 
   85             const double br = borderRadius.value< 
double >();
 
   86             const int fw = frameWidth.value< 
int >();
 
   88             if ( br > 0.0 && fw > 0 )
 
   90                 painter.setPen( QPen( Qt::color1, fw ) );
 
   91                 painter.setBrush( Qt::NoBrush );
 
   92                 painter.setRenderHint( QPainter::Antialiasing, 
true );
 
   94                 painter.drawPath( borderPath );
 
  101     const QImage mask = image.createMaskFromColor(
 
  102         QColor( Qt::color1 ).rgb(), Qt::MaskOutColor );
 
  104     return QBitmap::fromImage( mask );
 
  107 class QwtPlotPanner::PrivateData
 
  112         for ( 
int axis = 0; axis < QwtAxis::AxisPositions; axis++ )
 
  131     m_data = 
new PrivateData();
 
  133     connect( 
this, SIGNAL(
panned(
int,
int)),
 
  157         m_data->isAxisEnabled[axisId] = on;
 
  171         return m_data->isAxisEnabled[axisId];
 
  179     return parentWidget();
 
  185     return parentWidget();
 
  193         w = w->parentWidget();
 
  195     return qobject_cast< QwtPlot* >( w );
 
  201     const QWidget* w = 
canvas();
 
  203         w = w->parentWidget();
 
  205     return qobject_cast< const QwtPlot* >( w );
 
  218     if ( dx == 0 && dy == 0 )
 
  228     for ( 
int axisPos = 0; axisPos < QwtAxis::AxisPositions; axisPos++ )
 
  231             const QwtAxisId axisId( axisPos );
 
  233             if ( !m_data->isAxisEnabled[axisId] )
 
  270         return qwtBorderMask( 
canvas(), size() );
 
  280     const QWidget* cv = 
canvas();
 
  281     if ( cv && cv->inherits( 
"QGLWidget" ) )
 
  285         QPixmap pm( cv->size() );
 
  288         QPainter painter( &pm );
 
  289         const_cast< QwtPlot* 
>( 
plot() )->drawCanvas( &painter );
 
  298 #include "moc_qwt_plot_panner.cpp" 
static void fillPixmap(const QWidget *, QPixmap &, const QPoint &offset=QPoint())
static qreal devicePixelRatio(const QPaintDevice *)
QwtPanner provides panning of a widget.
virtual QBitmap contentsMask() const
Calculate a mask for the contents of the panned widget.
virtual QPixmap grab() const
void panned(int dx, int dy)
void setAxisScale(QwtAxisId, double min, double max, double stepSize=0)
Disable autoscaling and specify a fixed scale for a selected axis.
virtual void replot()
Redraw the plot.
void setAutoReplot(bool=true)
Set or reset the autoReplot option.
virtual QwtScaleMap canvasMap(QwtAxisId) const
const QwtScaleDiv & axisScaleDiv(QwtAxisId) const
Return the scale division of a specified axis.
QWidget * canvas()
Return observed plot canvas.
virtual QBitmap contentsMask() const override
QwtPlotPanner(QWidget *)
A panner for the canvas of a QwtPlot.
void setAxisEnabled(QwtAxisId axisId, bool on)
En/Disable an axis.
virtual ~QwtPlotPanner()
Destructor.
virtual void moveCanvas(int dx, int dy)
bool isAxisEnabled(QwtAxisId) const
QwtPlot * plot()
Return plot widget, containing the observed plot canvas.
virtual QPixmap grab() const override
double lowerBound() const
double upperBound() const
double transform(double s) const
double invTransform(double p) const
bool isValid(int axisPos)
bool isXAxis(int axisPos)