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"
#include "qpainter.h"

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


#include <cassert>

using std::vector;

using namespace hippodraw;

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

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 ();
}

void
QtViewWidget::
paintEvent ( QPaintEvent * ev )
{

  if ( m_plotter == 0 ) return;

  prepareMarginRect ();

  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 ();
  }
}

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

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

  // Adjust the width if the aspect ratio needs changing.
  if ( m_plotter != 0 ) {
    double ratio = m_plotter -> getAspectRatio ();
    if ( ratio != 0. ) {
      double w = width ();
      double h = height ();
      double diff = ratio - w / h;
      if ( diff > 0.00001 ) {
        int new_h = height();
        int new_w = static_cast < int > ( w * ratio );
        setFixedSize ( new_w, new_h );
        prepareMarginRect ();
      }
    }
  }
  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::
setGeometry ( int x, int y, int w, int h )
{
  QWidget::setGeometry ( x, y, w, h );
  if ( m_plotter != 0 ) { 
    prepareMarginRect ();
  }
}

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


void
QtViewWidget::
resizeEvent ( QResizeEvent * event )
{
  QWidget::resizeEvent ( event );
  if ( m_plotter != 0 ) {
    prepareMarginRect ();
  }
}

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

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

void
QtViewWidget::
fillPickedPoint ( double x, double y, 
                  std::vector < double > & picked ) const
{
  double xx = marginToUserX ( x );
  double yy = marginToInvertedUserY ( y );

  m_plotter -> fillPickedPointFrom ( xx, yy, 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::
#if QT_VERSION < 0x040000
transformAndFill ( QPointArray & array,
#else
transformAndFill ( QPolygon & array,
#endif
                   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() );

#if QT_VERSION < 0x040000
  QPointArray array ( size );
#else
  QPolygon array ( size );
#endif
  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() );

#if QT_VERSION < 0x040000
  QPointArray array ( size );
#else
  QPolygon array ( size );
#endif
  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 ();
  }
}