QtViewImp.cxx

Go to the documentation of this file.

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

#include "QtViewImp.h"

#include "DrawBorder.h"
#include "PlotterEvent.h"
#include "QtFont.h"

#include "axes/Range.h"
#include "graphics/Color.h"
#include "plotters/PlotterBase.h"

#include <qapplication.h>
#include <qpainter.h>
#include <qpointarray.h>

#include <cassert>

using namespace hippodraw;

using std::vector;

std::map < hippodraw::Line::Style, Qt::PenStyle > QtViewImp::s_line_style;

QtViewImp::
QtViewImp ( PlotterBase * plotter )
  : ViewBase ( plotter ),
    m_inspector ( 0 ),
    m_painter ( 0 ),
    m_font_default ( "helvetica" )
{
  if ( s_line_style.empty () ) {
    s_line_style [ Line::Solid ]      = Qt::SolidLine;
    s_line_style [ Line::Dash ]       = Qt::DashLine;
    s_line_style [ Line::Dot ]        = Qt::DotLine;
    s_line_style [ Line::DashDot ]    = Qt::DashDotLine;
    s_line_style [ Line::DashDotDot ] = Qt::DashDotDotLine;
    s_line_style [ Line::Invisible ]  = Qt::NoPen;
  }
}

void
QtViewImp::
setInspector ( QObject * inspector )
{
  m_inspector = inspector;
}

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

  if (  m_inspector != 0 ) {
    Observable * o = const_cast < Observable * > ( display );
    PlotterBase * plotter = dynamic_cast < PlotterBase * > ( o );
    PlotterEvent * event = new PlotterEvent ( plotter );
    QApplication::removePostedEvents ( m_inspector );
    QApplication::postEvent ( m_inspector, event );
  }

}

/* virtual */
HippoRectangle QtViewImp::getMarginRect () const
{
  return m_plotter->getMarginRect();
}

void QtViewImp::endPlot ()
{
}

float QtViewImp::userToDrawX ( double xx ) const
{
  return m_plotter->userToMarginX( xx );
}

float QtViewImp::userToDrawY ( double yy ) const
{
  return  m_plotter->userToInvertedMarginY( yy );
}

float QtViewImp::userToDrawColor ( double c ) const
{
  return m_plotter->userToMarginColor( c );
}

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

  m_painter->drawLineSegments ( array );

}


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

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


/* virtual */
void 
QtViewImp::
drawPoints ( const std::vector<double> & x,
             const std::vector<double> & y,
             hippodraw::Symbol::Type type, 
             float sym_size, 
             const Color & color )
{
  m_painter->save();
  
  int i_sym_size = (int)(sym_size/2);

  int rgb[3];
  rgb[0] = color.getRed();
  rgb[1] = color.getGreen();
  rgb[2] = color.getBlue();
  QColor qcolor ( rgb[0], rgb[1], rgb[2] );

  m_painter->setPen ( qcolor );

  QPointArray triangleArray ( 3 );

  for (unsigned int i = 0; i < x.size(); i++)
    {
      int originX = toViewX ( x[i] );
      int originY = toViewY ( y[i] );
      
      switch ( type )
        {



        case Symbol::SOLIDSQUARE:
          
          m_painter->fillRect ( ( toViewX (x[i]) - (i_sym_size) ), 
                                ( toViewY (y[i]) - (i_sym_size) ),
                                (i_sym_size*2 + 1 ),
                                (i_sym_size*2 + 1 ),
                                ( qcolor ) );
          
          break;



        case Symbol::SQUARE:  
          m_painter -> drawRect ( toViewX ( x[i] ) - i_sym_size,
                                  toViewY ( y[i] ) - i_sym_size,
                                  2*i_sym_size + 1,
                                  2*i_sym_size + 1 );
          break;

        case Symbol::TRIANGLE:
          triangleArray.setPoint ( 0, ( toViewX (x[i]) ), 
                              ( toViewY (y[i]) + (i_sym_size) ) );

          triangleArray.setPoint ( 1, ( toViewX (x[i]) + (i_sym_size) ),
                              ( toViewY (y[i]) - (i_sym_size) ) );


          triangleArray.setPoint ( 2, ( toViewX (x[i]) - (i_sym_size) ),
                              ( toViewY (y[i]) - (i_sym_size) ) );
          
          m_painter -> setBrush ( Qt::NoBrush );
          m_painter->drawPolygon (triangleArray);
          break;

        case Symbol::FILLED_TRIANGLE:
          
          triangleArray.setPoint ( 0, ( toViewX (x[i]) ), 
                              ( toViewY (y[i]) + (i_sym_size) ) );

          triangleArray.setPoint ( 1, ( toViewX (x[i]) + (i_sym_size) ),
                              ( toViewY (y[i]) - (i_sym_size) ) );


          triangleArray.setPoint ( 2, ( toViewX (x[i]) - (i_sym_size) ),
                              ( toViewY (y[i]) - (i_sym_size) ) );
          
          m_painter->setBrush (qcolor);

          m_painter->drawPolygon (triangleArray);
          
          break;


        case Symbol::CIRCLE:

          m_painter->drawEllipse ( ( toViewX (x[i]) - (i_sym_size) ), 
                                   ( toViewY (y[i]) - (i_sym_size) ),
                                   ( i_sym_size*2 + 1 ),
                                   ( i_sym_size*2 + 1 ) );
          
          break;


        case Symbol::FILLED_CIRCLE:

          m_painter->setBrush (qcolor);

          m_painter->drawPie ( ( toViewX (x[i]) - (i_sym_size) ), 
                               ( toViewY (y[i]) - (i_sym_size) ),
                               ( i_sym_size*2 + 1 ),
                               ( i_sym_size*2 + 1 ),
                               ( 16 * 0 ),
                               ( 16 * 360 ) );

          break;

        case Symbol::PLUS:
          m_painter -> drawLine ( originX - i_sym_size, originY,
                                  originX + i_sym_size, originY );
          m_painter -> drawLine ( originX, originY - i_sym_size,
                                  originX, originY + i_sym_size );
          break;
          
        case Symbol::TIMES:
          m_painter -> drawLine ( originX - i_sym_size, originY - i_sym_size,
                                  originX + i_sym_size, originY + i_sym_size );
          m_painter -> drawLine ( originX + i_sym_size, originY - i_sym_size,
                                  originX - i_sym_size, originY + i_sym_size );
          break;
          
        default:
          break;
        
        }
    }
  
  m_painter->restore();
  
}

void 
QtViewImp::
drawPoints ( const std::vector< double > & x,
             const std::vector< double > & y,
             hippodraw::Symbol::Type type, 
             float sym_size )
{

}

void 
QtViewImp::
drawPoints ( const std::vector< double > & x,
             const std::vector< double > & y,
             const std::vector< Color > & colors,
             hippodraw::Symbol::Type type, 
             float sym_size )
{
  m_painter->save();
  
  int i_sym_size = (int)(sym_size/2);

  if ( i_sym_size == 0 &&
       type == Symbol::SOLIDSQUARE ) {
    type = Symbol::SQUARE;
  }

  QPointArray triangleArray ( 3 );

  for (unsigned int i = 0; i < x.size(); i++)
    {
      int o_x = toViewX ( x[i] );
      int o_y = toViewY ( y[i] );

      const Color & c = colors[i];
      QColor qcolor ( c.getRed (), c.getGreen(), c.getBlue () );
      m_painter->setPen ( qcolor );
      
      switch ( type )
        {
        case Symbol::SOLIDSQUARE:
          m_painter->fillRect ( ( toViewX (x[i]) - (i_sym_size) ), 
                                ( toViewY (y[i]) - (i_sym_size) ),
                                (i_sym_size*2 ),
                                (i_sym_size*2 ),
                                ( qcolor ) );
          
          break;

        case Symbol::SQUARE:  
          m_painter -> drawRect ( o_x -i_sym_size, o_y - i_sym_size,
                                  2 * i_sym_size, 2 * i_sym_size );
          break;
          


        case Symbol::TRIANGLE:
          triangleArray.setPoint ( 0, ( toViewX (x[i]) ), 
                              ( toViewY (y[i]) + (i_sym_size) ) );

          triangleArray.setPoint ( 1, ( toViewX (x[i]) + (i_sym_size) ),
                              ( toViewY (y[i]) - (i_sym_size) ) );


          triangleArray.setPoint ( 2, ( toViewX (x[i]) - (i_sym_size) ),
                              ( toViewY (y[i]) - (i_sym_size) ) );
          
          m_painter->setBrush ( Qt::NoBrush );
          m_painter->drawPolygon (triangleArray);
          
          break;



        case Symbol::FILLED_TRIANGLE:
          
          triangleArray.setPoint ( 0, ( toViewX (x[i]) ), 
                              ( toViewY (y[i]) + (i_sym_size) ) );

          triangleArray.setPoint ( 1, ( toViewX (x[i]) + (i_sym_size) ),
                              ( toViewY (y[i]) - (i_sym_size) ) );


          triangleArray.setPoint ( 2, ( toViewX (x[i]) - (i_sym_size) ),
                              ( toViewY (y[i]) - (i_sym_size) ) );
          
          m_painter->setBrush (qcolor);

          m_painter->drawPolygon (triangleArray);
          
          break;


        case Symbol::CIRCLE:

          m_painter->drawEllipse ( ( toViewX (x[i]) - (i_sym_size) ), 
                                   ( toViewY (y[i]) - (i_sym_size) ),
                                   (i_sym_size*2 ),
                                   (i_sym_size*2 ) );
          
          break;


        case Symbol::FILLED_CIRCLE:

          m_painter->setBrush (qcolor);

          m_painter->drawPie ( ( toViewX (x[i]) - (i_sym_size) ), 
                               ( toViewY (y[i]) - (i_sym_size) ),
                               ( i_sym_size*2 ),
                               ( i_sym_size*2 ),
                               ( 16 * 0 ),
                               ( 16 * 360 ) );

          break;

        case Symbol::PLUS:
          m_painter -> drawLine ( o_x - i_sym_size, o_y,
                                  o_x + i_sym_size, o_y );
          m_painter -> drawLine ( o_x, o_y - i_sym_size,
                                  o_x, o_y + i_sym_size );
          break;
          
        case Symbol::TIMES:
          m_painter -> drawLine ( o_x - i_sym_size, o_y - i_sym_size,
                                  o_x + i_sym_size, o_y + i_sym_size );
          m_painter -> drawLine ( o_x + i_sym_size, o_y - i_sym_size,
                                  o_x - i_sym_size, o_y + i_sym_size );
          break;
          
        default:
          break;
        
        }
    }
  
  m_painter->restore();

}

QPen
QtViewImp::
createPen ( const Color & color, float size, hippodraw::Line::Style style )
{
  int rgb[3];
  rgb[0] = color.getRed();
  rgb[1] = color.getGreen();
  rgb[2] = color.getBlue();
  QColor qcolor ( rgb[0], rgb[1], rgb[2] );

  unsigned int isize = static_cast < unsigned int > ( size );
  Qt::PenStyle pen_style = s_line_style [ style ];

  return QPen ( qcolor, isize, pen_style );
}

void 
QtViewImp::
drawPolyLine ( const std::vector< double > & x,
               const std::vector< double > & y,
               hippodraw::Line::Style style,
               const Color & color,
               float size )
{
  m_painter->save();

  QPen pen = createPen ( color, size, style );
  m_painter->setPen ( pen );
  m_painter -> setBrush ( Qt::NoBrush );
  drawMethod ( x, y, style, 0 );

  m_painter->restore();

}

void 
QtViewImp::
drawLines ( const std::vector< double > & x,
            const std::vector< double > & y,
            hippodraw::Line::Style style,
            const Color & color,
            float size )
{

  m_painter->save();

  QPen pen = createPen ( color, size, style );
  m_painter->setPen ( pen );

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

  QPointArray array ( xsize );
  transformAndFill ( array, x, y,
                     &QtViewImp::toViewX, &QtViewImp::toViewY );

  m_painter->drawLineSegments ( array );
  
  m_painter->restore();

}

void
QtViewImp::
drawColorLines ( const std::vector< double > & x,
                 const std::vector< double > & y,
                 hippodraw::Line::Style style,
                 const std::vector < Color > & colors,
                 float size )
{
  unsigned int ssize = x.size();
  assert ( ssize == y.size() );
  assert ( ssize == colors.size() );

  for ( unsigned int i = 0; i < ssize; i+=2 ) {
    
    m_painter->save();
    const Color & color = colors[i];
    QColor qcolor ( color.getRed (), color.getGreen (), color.getBlue() );
    QPen pen ( qcolor, static_cast < int > (size) );
    Qt::PenStyle pen_style = s_line_style [ style ];
    pen.setStyle ( pen_style );
    m_painter->setPen ( pen );
      
    int x1 = toViewX ( x[i] );
    int x2 = toViewX ( x[i+1] );
    int y1 = toViewY ( y[i] );
    int y2 = toViewY ( y[i+1] );
    
    m_painter->drawLine ( x1, y1, x2, y2 );

    m_painter->restore();

  }
  
}

void 
QtViewImp::
drawViewLines ( const std::vector< double > & x,
                const std::vector< double > & y,
                hippodraw::Line::Style style,
                bool color,
                float size )
{

  m_painter->save();

  QPen pen ( (m_painter->pen()).color(), (int)(size) );
  Qt::PenStyle pen_style = s_line_style [ style ];
  pen.setStyle ( pen_style );
  m_painter->setPen ( pen );

  drawViewMethod ( x, y, style, 0 ); // last argument was default color

  m_painter->restore();

}

void 
QtViewImp::
drawViewLines ( const std::vector< double > & x,
                const std::vector< double > & y,
                hippodraw::Line::Style style,
                const Color & color,
                float size )
{

  m_painter->save();

  QPen pen = createPen ( color, size, style );
  m_painter->setPen ( pen );

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

  QPointArray array ( xsize );
  transformAndFill ( array, x, y,
                     &QtViewImp::toCanvasX, &QtViewImp::toCanvasY );

  m_painter->drawLineSegments ( array );

  m_painter->restore();

}

void 
QtViewImp::
draw_Text ( const std::string &s, 
            float xx, float yy, float fontsize, 
            float angle, char xp, char yp, bool resize,
            QFont & font )
{
  int i_x = static_cast< int > ( xx );
  int i_y = static_cast< int > ( yy );
  int i_font = static_cast < int > ( fontsize );
  
  if ( fontsize > 0 ) {
    font.setPointSize( i_font );
    font.setPixelSize( i_font );
  }
  
  if ( m_painter == 0 ) return;

  m_painter->setFont ( font );

  QString qstring ( s.c_str() );

  QFontMetrics metrics1 ( font );
  QRect new_rect1 = metrics1.boundingRect ( qstring );
  int h1 = new_rect1.height ();

  if ( fontsize > 0 ) {
    while ( h1 >= fontsize ){
    
      i_font-- ;

      if ( i_font < 1 ) break;

      font.setPixelSize ( i_font );

      QFontMetrics metrics2 ( font );
      QRect new_rect2 = metrics2.boundingRect ( qstring );
      int h2 = new_rect2.height ();

      h1 = h2;
    }
  }

  if ( resize == true ) {

    // This part of the code makes sense only for TextReps. Nobody else
    // should call draw_Text with resize == true. It will not
    // work if the text rep draws the strings that appear on the bottom of
    // the display before the ones that appear near the top.

    QFontMetrics metrics ( font );
    QRect new_rect = metrics.boundingRect ( qstring );

    int w = new_rect.width ();
    int h = new_rect.height ();

    HippoRectangle rect = getDrawRect ();

    // fix the height if this is not top string
    int delta_y = i_y - static_cast < int > ( rect.getY () );
    if ( delta_y > 0 ) {
      h += delta_y;
    }

    // fix the width if this is not left positioned string
    int delta_x = i_x - static_cast < int > ( rect.getX () );
    if ( delta_x > 0 ) {
      w += delta_x;
    }
    // need a little extra of the width for some reason.
    setDrawRect ( rect.getX (), rect.getY (), 1.2 * w, 2. * h );
  }

  HippoRectangle rect = getDrawRect ();

  int i_w = static_cast < int > ( rect.getWidth () );
  int i_h = static_cast < int > ( rect.getHeight () );

  QRect text_rect = m_painter->boundingRect ( 0, 0,
                                          i_h, i_w,
                                          Qt::AlignLeft | Qt::AlignTop,
                                          qstring );
  int dx = 0;
  int dy = 0;

  if ( angle == 0.0 )
    {
      
      switch ( xp ) {
      case 'l' :
      case 'L' :
        dx = i_x;
        break;
      case 'c' :
      case 'C' :
        dx = i_x - text_rect.width () / 2;
        break;
      case 'r' :
      case 'R' :
        dx = i_x - text_rect.width ();
        break;
      default:
        dx = i_x;
      }

      switch ( yp ) {
      case 't' :
      case 'T' :
        dy = i_y;
        break;
      case 'c' :
      case 'C' :
        dy = i_y - text_rect.height () / 2;
        break;
      case 'b' :
      case 'B' :
        dy = i_y - text_rect.height ();
        break;
      default:
        dy = i_y;
      }

      text_rect.moveBy ( dx, dy );
      text_rect.setWidth ( text_rect.width() + 2 );
      text_rect.setHeight ( text_rect.height() + 2 );

      m_painter->drawText ( text_rect, Qt::AlignLeft | Qt::AlignTop,
                            qstring );
    }

  else // angle not 0.0
    {
      m_painter->save();
      
      m_painter->translate ( i_x, i_y );
      
      m_painter->rotate ( - angle );

      switch ( xp ) {
      case 'l' :
      case 'L' :
        dx = 0;
        break;
      case 'c' :
      case 'C' :
        dx = 0 - text_rect.width () / 2;
        break;
      case 'r' :
      case 'R' :
        dx = 0 - text_rect.width ();
        break;
      default:
        dx = 0;
      }

      switch ( yp ) {
      case 't' :
      case 'T' :
        dy = 0;
        break;
      case 'c' :
      case 'C' :
        dy = 0 - text_rect.height () / 2;
        break;
      case 'b' :
      case 'B' :
        dy = 0 - text_rect.height ();
        break;
      default:
        dy = 0;
      }

      text_rect.moveBy ( dx, dy );
      text_rect.setWidth ( text_rect.width() + 2 );
      text_rect.setHeight ( text_rect.height() + 2 );
            
      m_painter->drawText ( text_rect, Qt::AlignLeft | Qt::AlignTop,
                            qstring );
      
       m_painter->restore();

    }

}

void 
QtViewImp::
drawText ( const std::string &s, 
           float xx, float yy,
           float fontsize, float angle,
           char xp, char yp, bool resize )
{
  drawText ( s, xx, yy, fontsize, angle, xp, yp, resize, 0 );
}

void 
QtViewImp::
drawText ( const std::string &s, 
           float xx, float yy,
           float fontsize, float angle,
           char xp, char yp, bool resize,
           const FontBase * font )
{
  HippoRectangle rect = getDrawRect ();

  if ( font != 0 ) {
    const QtFont * qtfont = dynamic_cast < const QtFont * > ( font );
    const QFont & qfont = qtfont -> font();
    QFont & qf = const_cast < QFont & > ( qfont );

    draw_Text ( s, 
                (xx + rect.getX()), (yy + rect.getY () ), 
                fontsize, angle, 
                xp, yp, resize, qf );
  }
  else {
    draw_Text ( s, 
                (xx + rect.getX()), (yy + rect.getY () ), 
                fontsize, angle, 
                xp, yp, resize, m_font_default );
  }
}

void 
QtViewImp::
drawUserText ( const std::string &s, 
               float xx, float yy, 
               float fontsize, float angle,
               char xp, char yp )
{
  HippoRectangle rect = getDrawRect ();
  draw_Text ( s, 
              ( rect.getX () + userToDrawX ( xx ) ), 
              ( rect.getY () + userToDrawY ( yy ) ),
              fontsize, angle, xp, yp, false, m_font_default );
}

void 
QtViewImp::
drawMag ( float xx, float yy, int mag, float fontsize )
{
  drawMag ( xx, yy, mag, fontsize, m_font_default );
}

void 
QtViewImp::
drawMag ( float xx, float yy, int mag, float fontsize, QFont & font )
{
  int i_font = static_cast< int> ( fontsize );
  m_painter->save();

  font.setPointSize( i_font );
  m_painter->setFont ( font );
  
  m_painter->translate ( xx, yy );

  QString qs1 ( "x10" );
  m_painter->drawText ( 0, 0, qs1);

  m_painter->translate ( (qs1.length() * fontsize * 3 / 4), -fontsize/2 );

  QString str ( "%1" );
  QString qs2 = str.arg ( mag );
  m_painter->drawText ( 0, 0, qs2 );

  m_painter->restore();

}

void 
QtViewImp::
drawSquare ( double x1, double y1, double x2, double y2,
             int red, int green, int blue )
{
  int x = toViewX ( x1 );
  int w = toViewX ( x2 ) - x + 1;
  int y = toViewY ( y2 );
  int h = toViewY ( y1 ) - y + 1;
  
  const QColor color ( red, green, blue );

  m_painter->fillRect ( x, y, w, h, color );
}

void 
QtViewImp::
drawViewSquare ( float x1, float y1, float x2, float y2,
                 int red, int green, int blue )
{
  int x = toCanvasX ( x1 );
  int w = toCanvasX ( x2 ) - x + 1;
  int y = toCanvasY ( y2 );
  int h = toCanvasY ( y1 ) - y + 1;
  
  QColor color ( red, green, blue );

  m_painter->fillRect ( x, y, w, h, color );
}

void QtViewImp::setCrossX ( double val )
{
  m_plotter->setCrossX ( val );
}

void QtViewImp::setCrossY ( double val )
{
  m_plotter->setCrossY ( val );
}


void
QtViewImp::
setDefaultFont ( const QFont& font )
{
  m_font_default = font;
}

const QFont &
QtViewImp::
defaultFont()
{
  return m_font_default;
}

---