QtView.cxx

Go to the documentation of this file.

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

#include "QtView.h"

#include "DrawBorder.h"

#include "plotters/PlotterBase.h"

#include "qpainter.h"

#include <cassert>

using std::vector;

QtView::QtView ( PlotterBase * plotter )
  : QtViewImp ( plotter ),
#if QT_VERSION < 0x040000
    QCanvasRectangle ( 0 ),
#else
    Q3CanvasRectangle ( 0 ),
#endif
    m_filled ( false ),
    m_crosshairs ( false )
{
  assert ( plotter != 0 );

  m_plotter -> addObserver ( this );
  setEnabled ( false );
}

QtView::
~QtView ()
{
  m_plotter -> removeObserver ( this );
  // for SIP only
  delete m_plotter;
}

void
QtView::
drawWithPixmap ( QPainter & painter )
{
  // Before draing set the aspect ratio.
  double transform_aspect_ratio = getAspectRatio();
  const HippoRectangle rectOrg = getDrawRect ();

  int w = static_cast < int > ( rectOrg.getWidth() );
  int x = static_cast < int > ( rectOrg.getX () );
  int y = static_cast < int > ( rectOrg.getY () );
  
  if( transform_aspect_ratio > 0.0 )
    {
      double wth =  w;
      double hgt  = wth / transform_aspect_ratio; 
      setDrawRect( x, y, wth, hgt );
    }

  // Now work with the new rectangle
  const HippoRectangle rect = getDrawRect ();
  int width = static_cast < int > ( rect.getWidth () );
  int height = static_cast < int > ( rect.getHeight () );
  
  if ( m_filled == false ||
       isEnabled () == true ) {
    QPainter offscrPainter;
    ensureOffScrSize ( width, height );
    m_pixmap.fill ( );  // with white
    offscrPainter.begin ( & m_pixmap );
    offscrPainter.translate ( -x, -y );
    m_painter = & offscrPainter;
    drawSelf ();
    offscrPainter.end();
    m_filled = true;
    setEnabled ( false );
  }

  m_painter = & painter;
  painter.drawPixmap ( x, y, m_pixmap,
                       0, 0, width, height );
}

void
QtView::
setShowCrossHairs ( bool yes )
{
  m_crosshairs = yes;
}

void QtView::draw ( QPainter & painter )
{
  m_is_drawing = true;
  const QColor color ( "black" );
  painter.setPen ( color );

  QPaintDevice * dev = painter.device ();
  if ( m_plotter -> wantsPixmap () && 
       dev -> isExtDev () == false ) { // not a printer
    drawWithPixmap ( painter );
  }
  else {
    m_painter = & painter;
    drawSelf ();
  }

  if ( m_crosshairs ) {
    m_plotter -> drawCrossHairs ( this );
  }

  if ( isSelected () )
    {
      DrawBorder * border = DrawBorder::instance();
      border->setView (this);
      border->draw();
    }
  m_is_drawing = false;
}

void QtView::drawShape ( QPainter & painter )
{
  draw ( painter );
}

HippoRectangle QtView::getDrawRect () const
{
  return HippoRectangle ( x(), y(), width(), height() );
}

void
QtView::
update ( const Observable * display )
{
  if ( m_is_drawing == true ) return;

  if ( display != 0 ) { // from Observeable object
    m_filled = false;
  }
#if QT_VERSION < 0x040000
  QCanvasItem::update ();
#else
  Q3CanvasItem::update ();
#endif
}

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

void QtView::setDrawRect ( float x, float y, float w, float h )
{
    setX ( x );
    setY ( y );
    int iw = static_cast< int > ( w );
    int ih = static_cast< int > ( h );

    setSize ( iw, ih );
    m_filled = false;
}

void QtView::initPlot( double transform_aspect_ratio )
{
  const HippoRectangle draw = getDrawRect();
  double w = draw.getWidth();
  double h = draw.getHeight();
  double draw_aspect_ratio = w / h;
  
  // If we need to set the aspect ratio AND it is not already set
  if( transform_aspect_ratio > 0.0 )
    if( !( 0.999 * transform_aspect_ratio  < draw_aspect_ratio ) ||
        !( draw_aspect_ratio < 1.001 * transform_aspect_ratio  )  )
      setDrawRect( x(), y(), width (), width () / transform_aspect_ratio );
  
}

void QtView::endPlot ()
{
}

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

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

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

int QtView::toCanvasX ( double dx ) const
{
  return static_cast < int > ( x() + dx );
}

int QtView::toCanvasY ( double dy ) const
{
  return static_cast < int > ( y() + dy );
}

void
QtView::
transformAndFill ( QPointArray & array,
                   const std::vector< double > & x,
                   const std::vector< double > & y,
                   int (QtView::* xfunc) ( double ) const,
                   int (QtView::* 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 QtView::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,
                     &QtView::toCanvasX, &QtView::toCanvasY );

  m_painter->drawLineSegments ( array );

}


void QtView::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,
                     &QtView::toViewX, &QtView::toViewY );

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

void
QtView::
ensureOffScrSize ( int osw, int osh )
{
  if ( osw > m_pixmap.width() || osh > m_pixmap.height() ) {
        m_pixmap.resize(QMAX(osw,m_pixmap.width()),
                      QMAX(osh,m_pixmap.height()));
  }
  else if ( m_pixmap.width() == 0 || m_pixmap.height() == 0 ) {
        m_pixmap.resize( QMAX( m_pixmap.width(), 1),
                       QMAX( m_pixmap.height(), 1 ) );
  }
}

void
QtView::
setPageWidth ( int upage_w )
{
  m_upage_w = upage_w;
}

---