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"
#if QT_VERSION < 0x040000
#else
#include <QtGui/QPaintEngine>
#endif

#include <cassert>
#include <iostream>

using std::vector;

using namespace hippodraw;

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 ()
{
  if ( m_plotter != 0 ) {
    m_plotter -> removeObserver ( this );
  }
  // for SIP only
  //  delete m_plotter;
}

void
QtView::
drawWithPixmap ( QPainter & painter )

{
  // Before drawing set the aspect ratio.
  const Rect rectOrg = getDrawRect ();

  int x = static_cast < int > ( rectOrg.getX () );
  int y = static_cast < int > ( rectOrg.getY () );

  
  
  // Now work with the new rectangle
  const Rect 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 )

{
  if ( m_plotter == 0 ) return;

  m_is_drawing = true;
  const QColor color ( "black" );
  painter.setPen ( color );

  QPaintDevice * dev = painter.device ();
#if QT_VERSION < 0x040000
  if ( m_plotter -> wantsPixmap () && 
       dev -> isExtDev () == false ) { // not a printer
    drawWithPixmap ( painter );
  }
#else
  QPaintEngine * pe = dev -> paintEngine ();
  QPaintEngine::Type type = pe-> type ();
  if ( m_plotter -> wantsPixmap () && 
       type != QPaintEngine::PostScript ) { 
    drawWithPixmap ( painter );
  }
#endif
  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 );
}

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

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

  if ( display != 0 ) { // from Observable object
    m_filled = false;
  }

  // Update the size of the draw rectangle first. ( For aspect ratio. )
  updateDrawRect();

#if QT_VERSION < 0x040000
  QCanvasItem::update ();
#else
  Q3CanvasItem::update ();
#endif
}

void QtView::updateDrawRect ()
{
  double aspect = getAspectRatio();
  Rect drawrect = getDrawRect();
  if ( aspect > 0 ) {
    setDrawRect ( drawrect.getX(), drawrect.getY(), 
                  drawrect.getHeight()*aspect, drawrect.getHeight() );
  } else {
    setDrawRect ( drawrect );
  }
}

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

void QtView::setDrawRect ( Rect & rect )
{
  setDrawRect ( rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight() );
}

  

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

    prepareMarginRect ();
    float new_width = m_margin_rect.getX () + m_margin_rect.getWidth() + 20.;
    iw = static_cast < int > ( new_width );

    setSize ( iw, ih );

    m_filled = false;
}

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

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

void
QtView::
fillPickedPoint ( double dx, double dy,
                  std::vector < double > & picked ) const
{
  if ( m_plotter != 0 ) {
    double xx;
    if (m_plotter -> isReverse())
      xx = marginToInvertedUserX ( dx - x() );
    else
      xx = marginToUserX ( dx - x() );
    double yy = marginToInvertedUserY ( dy - y() );

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

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

#if QT_VERSION < 0x040000
  QPointArray array ( size );
#else
  QPolygon array ( size );
#endif

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


bool
QtView::
isTextView() const
{
  return m_plotter->isTextPlotter();
}