QtViewWidget.cxx

Go to the documentation of this file.

// inconsistent dll linkage
#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif

#include "QtViewWidget.h"

#include "DrawBorder.h"
#include "qwt_paint_buffer.h"

#include "plotters/PlotterBase.h"

#if QT_VERSION < 0x040000
#else
//Added by the Qt porting tool:
#include <QMouseEvent>
#include <QPaintEvent>
#endif

#include "qpainter.h"

#include <cassert>

using std::vector;

QtViewWidget::
QtViewWidget ( QWidget * parent, const char * name,  Qt::WFlags wflags )
  : QtViewImp ( 0 ), // sets m_plotter to 0
    QWidget ( parent, name, wflags )
{
  setGeometry ( 0, 0, 200, 200 );
  setPaletteBackgroundColor ( QColor ( "white" ) );
  setDoubleBuffering(0);
}

/* virtual */
QtViewWidget::~QtViewWidget ()
{
}

/* virtual */
QSize
QtViewWidget::
sizeHint () const
{
  return size();
}

void
QtViewWidget::
setPlotter ( PlotterBase * plotter )
{
  ViewBase::setPlotter ( plotter );
  plotter -> addObserver ( this );
}

void QtViewWidget::draw ( QPainter & painter )
{
  m_painter = & painter;

  drawSelf ();
}

/* virtual */
void QtViewWidget::paintEvent ( QPaintEvent * ev )
{
  if ( m_plotter == 0 ) return;

  if (double_buffer == 1)
  {
    // Use double-buffering
    const QRect &ur = ev->rect();
    if ( ur.isValid() )
    {
      QwtPaintBuffer paintBuffer(this, ur);
      m_painter = paintBuffer.painter();
      drawSelf ();
    }
  }
  else
  {
    QPainter painter ( this );
    m_painter = & painter;
    drawSelf ();
  }
}

/* virtual */
HippoRectangle QtViewWidget::getDrawRect () const
{
  const QRect & rect = geometry ();
  return HippoRectangle ( 0.0, 0.0, rect.width(), rect.height() );
}

/* virtual */
void QtViewWidget:: update ( const Observable * display )
{
  if ( display == 0 ) return; 

  QtViewImp::update ( display );

  QWidget::update ();
}

void QtViewWidget::setDrawRect ( const QRect & rect )
{
  setDrawRect ( rect.x (), rect.y (), rect.width (), rect. height () );
}

void QtViewWidget::setDrawRect ( float x, float y, float w, float h )
{
  int ix = static_cast < int > ( x );
  int iy = static_cast < int > ( y );
  int iw = static_cast < int > ( w );
  int ih = static_cast < int > ( h );

  setGeometry ( ix, iy, iw, ih );
}

void QtViewWidget::initPlot ( double aspect )
{

  if ( aspect > 0 )
    {
      setDrawRect ( x(), 
                    y(), 
                    width (), 
                    width () / aspect
                    );
    }

}

void QtViewWidget::endPlot ()
{
}

int QtViewWidget::toViewX ( double datX ) const
{
  return static_cast< int > ( m_plotter->userToMarginX ( datX ) );
}

int QtViewWidget::toViewY ( double datY ) const
{
  return static_cast< int > ( m_plotter->userToInvertedMarginY ( datY ) );
}

void
QtViewWidget::
fillPickedPoint ( double x, double y, 
                  std::vector < double > & picked ) const
{
  m_plotter -> fillPickedPoint ( x, y, picked );
}

int QtViewWidget::toCanvasX ( double dx ) const
{
  return static_cast < int > ( dx );
}

int QtViewWidget::toCanvasY ( double dy ) const
{
  return static_cast < int > ( dy );
}

void
QtViewWidget::
transformAndFill ( QPointArray & array,
                   const std::vector< double > & x,
                   const std::vector< double > & y,
                   int (QtViewWidget::* xfunc) ( double ) const,
                   int (QtViewWidget::* yfunc) ( double ) const )
{

  unsigned int size = x.size();
  assert ( size == y.size() );

  for ( unsigned int i = 0; i < size; i++ ) {
    int ix = (this->*xfunc) ( x[i] );
    int iy = (this->*yfunc) ( y[i] );
    array.setPoint ( i , ix, iy );
  }

}

void 
QtViewWidget::
drawViewMethod ( const std::vector< double > & x,
                 const std::vector< double > & y,
                 int style,
                 int color )
{
  unsigned int size = x.size();
  assert ( size == y.size() );

  QPointArray array ( size );
  transformAndFill ( array, x, y,
                     &QtViewWidget::toCanvasX, &QtViewWidget::toCanvasY );

  m_painter->drawLineSegments ( array );
}

void 
QtViewWidget::
drawMethod ( const std::vector < double > & x,
             const std::vector < double > & y,
             int style,
             int color )
{

  unsigned int size = x.size();
  assert ( size == y.size() );

  QPointArray array ( size );
  transformAndFill ( array, x, y,
                     &QtViewWidget::toViewX, &QtViewWidget::toViewY );

  m_painter->drawPolyline ( array, 0, -1 );
}

void
QtViewWidget::
setDoubleBuffering( unsigned dblbuf)
{
  double_buffer = dblbuf;
}

void
QtViewWidget::
mousePressEvent ( QMouseEvent * e )
{
  if ( e -> state () == Qt::ControlButton ) {
    m_plotter -> toggleActivePlot ();
    e -> accept ();
  }
}

---