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 <qpixmap.h>
#include <qwmatrix.h>

#include <qfile.h>
#include <qdir.h>
#include <qdatetime.h>

#if QT_VERSION < 0x040000
#include <qpointarray.h>
#else
#include <QtGui/QPolygon>
#include <QtCore/QTextStream>
#endif

#include <cstdlib>
#include <cassert>

using namespace hippodraw;

using std::vector;

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

QtViewImp::
QtViewImp ()
  :DataView (),
   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;
  }
  m_eq_png.clear();

  setTmpDirName();
}
   

QtViewImp::
QtViewImp ( PlotterBase * plotter )
  : DataView ( 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;
  }
  m_eq_png.clear();
  setTmpDirName();
}

void
QtViewImp::
setTmpDirName() {
   char * tmp_dir(::getenv("TMP"));
   if (tmp_dir) {
      m_tmpDirName = tmp_dir + std::string("/temp_latex");
   } else {
      m_tmpDirName = "temp_latex";
   }
}

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

}

float QtViewImp::userToDrawXAutoInv ( double xx ) const
{
  if (m_plotter -> isReverse())
    return userToInvertedMarginX( xx );
  else 
    return userToMarginX( xx );
}

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

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

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

void
QtViewImp::
#if QT_VERSION < 0x040000
transformAndFill ( QPointArray & array,
#else
transformAndFill ( QPolygon & array,
#endif
                   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, int )
{

  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,
                     &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() );

#if QT_VERSION < 0x040000
  QPointArray array ( size );
#else
  QPolygon array ( size );
#endif
  transformAndFill ( array, x, y,
                     &QtViewImp::toViewX, &QtViewImp::toViewY );

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


void 
QtViewImp::
drawPoints ( const std::vector<double> & x,
             const std::vector<double> & y,
             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 );

#if QT_VERSION < 0x040000
  QPointArray triangleArray ( 3 );
#else
  QPolygon triangleArray ( 3 );
#endif

  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 > &,
             const std::vector< double > &,
             Symbol::Type, 
             float )
{

}

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

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

#if QT_VERSION < 0x040000
  QPointArray triangleArray ( 3 );
#else
  QPolygon triangleArray ( 3 );
#endif

  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, 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::
drawPolygon ( const std::vector < double > & x,
              const std::vector < double > & y,
              const Color & color,
              const Color & edge
              )
{
  m_painter->save();

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

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

  int rgb2[3];
  rgb2[0] = edge.getRed();
  rgb2[1] = edge.getGreen();
  rgb2[2] = edge.getBlue();
  QColor qcolor2 ( rgb2[0], rgb2[1], rgb2[2] );

#if QT_VERSION < 0x040000
  QPointArray array ( size );
#else
  QPolygon array ( size );
#endif
  transformAndFill ( array, x, y,
                     &QtViewImp::toViewX, &QtViewImp::toViewY );

  m_painter->setBrush(qcolor);
  m_painter->setPen(qcolor2);
  m_painter->drawPolygon(array);

  m_painter->restore();

}

void 
QtViewImp::
drawPolyLine ( const std::vector< double > & x,
               const std::vector< double > & y,
               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,
            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() );

#if QT_VERSION < 0x040000
  QPointArray array ( xsize );
#else
  QPolygon array ( xsize );
#endif
  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,
                 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,
                Line::Style style,
                bool,
                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,
                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() );

#if QT_VERSION < 0x040000
  QPointArray array ( xsize );
#else
  QPolygon array ( xsize );
#endif
  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, const QColor & color  )
{
  assert ( fontsize > 0 );
  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 );

  m_painter -> setPen ( color );

  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 );
#if QT_VERSION < 0x040000
    int lines = qstring.contains ( "\n" );
#else
    int lines = qstring.count();
#endif
    QStringList sl = QStringList::split ( '\n', qstring );
    int maxw = 0;
#if QT_VERSION < 0x040000
    for ( QValueList<QString>::size_type i = 0; i < sl.count (); i++ ) {
#else
    for ( QList<QString>::size_type i = 0; i < sl.count (); i++ ) {
#endif
      QString s = sl[i];
      QRect sr = metrics.boundingRect ( s );
      maxw = std::max ( maxw, sr.width () );
    }
    int w = new_rect.width ();
    int h = new_rect.height ();
    h *= ( lines + 1 );
    Rect 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.
#ifdef _MSC_VER
    maxw *= 1.6;
#endif
    setDrawRect ( rect.getX (), rect.getY (), 1.2 * maxw, 4. * h );
  }

  Rect 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 )
{
  Color black; // default constructor
  drawText ( s, xx, yy, fontsize, angle, xp, yp, resize, 0, & black );
}

void 
QtViewImp::
drawText ( const std::string &s, 
           float xx, float yy,
           float fontsize, float angle,
           char xp, char yp, bool resize,
           const FontBase * font, const Color * color )
{
  Rect rect = getDrawRect ();
  if ( color == 0 ) {
    color = new Color (); // black
  }
  QColor qcolor ( color->getRed(), color->getGreen(), color->getBlue() );
  m_painter -> setPen ( qcolor );

  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, qcolor );
  }
  else {
    draw_Text ( s, 
                (xx + rect.getX()), (yy + rect.getY () ), 
                fontsize, angle, 
                xp, yp, resize, m_font_default, qcolor );
  }
}

void 
QtViewImp::
drawSquare ( double x1, double y1, double x2, double y2,
             int red, int green, int blue )
{
  // If reversed, larger coordinate is to the left
  if (m_plotter -> isReverse()) {
    if (x1<x2) std::swap(x1,x2);
  } else {
    if (x2<x1) std::swap(x1,x2);
  }

  if (y2<y1) std::swap(y1,y2);
  
  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;
}

void 
QtViewImp::
drawImage ( const std::string &filename, int position)
{
  QPixmap pixmap;

  // Manually add the directory. 
  QString fn ( (m_tmpDirName + "/"+filename).c_str() );
  switch ( position ){
  case 0: // Scale to fit the plot
    if (pixmap.load(fn)) {
      Rect rect = getDrawRect ();
      double x=rect.getX();
      double y=rect.getY();
      double h=rect.getHeight();
      double w=h*pixmap.width()/pixmap.height();
      setDrawRect(x,y,w,h);
      QRect qrect = QRect(static_cast<int>(x),
                          static_cast<int>(y),
                          static_cast<int>(w),
                          static_cast<int>(h) );
      m_painter->drawPixmap( qrect, pixmap ); 
    }
    break;
    
  case 1:
    if (pixmap.load(fn)) {
      Rect rect = getDrawRect ();
      Rect mr = getMarginRect ();
      double x=rect.getX()+mr.getX();
      double y=rect.getY();
      double h=pixmap.height()*0.8;
      double w=pixmap.width()*0.8;

      // Limit the size
      if ( h>36.0 ) {
        w=w*36.0 / h;
        h = 36.0;
      }

      if ( w>mr.getWidth() * 0.8 ) {
        double ratio = mr.getWidth() * 0.8 / w ;
        h *= ratio;
        w *= ratio;
      }

      x+=mr.getWidth()/2.0-w/2.0;
      QRect qrect = QRect(static_cast<int>(x),
                          static_cast<int>(y),
                          static_cast<int>(w),
                          static_cast<int>(h) );
      m_painter->drawPixmap (qrect, pixmap );
    }
    break;

  case 2:
    if (pixmap.load(fn)) {
      Rect rect = getDrawRect ();
      Rect mr = getMarginRect ();
      double x=rect.getX()+mr.getX();
      double y=rect.getY();
      double h=pixmap.height();
      double w=pixmap.width();

     // Limit the size
      if ( h>40.0 ) {
        w=w*40.0 / h;
        h = 40.0;
      }

      if ( w>mr.getWidth() * 0.8 ) {
        double ratio = mr.getWidth() * 0.8 / w ;
        h *= ratio;
        w *= ratio;
      }


      x+=mr.getWidth()/2.0-w/2.0;
      y+=rect.getHeight()-0.9*h;
      QRect qrect = QRect(static_cast<int>(x),
                          static_cast<int>(y),
                          static_cast<int>(w),
                          static_cast<int>(h) );
      m_painter->drawPixmap (qrect, pixmap );
    }
    break;

  case 3:
    if (pixmap.load(fn)) {
      QWMatrix m;
      m.rotate(-90.0);
      pixmap = pixmap.xForm(m);

      Rect rect = getDrawRect ();
      Rect mr = getMarginRect ();
      double x=rect.getX();
      double y=rect.getY()+mr.getY();
      double h=pixmap.height();
      double w=pixmap.width();

     // Limit the size
      if ( w>40.0 ) {
        h=h*40.0 / w;
        w = 40.0;
      }

      if ( h>mr.getHeight() * 0.8 ) {
        double ratio = mr.getHeight() * 0.8 / h ;
        h *= ratio;
        w *= ratio;
      }

      y+=mr.getHeight()/2.0-h/2.0;
      QRect qrect = QRect(static_cast<int>(x),
                          static_cast<int>(y),
                          static_cast<int>(w),
                          static_cast<int>(h) );
      m_painter->drawPixmap (qrect, pixmap);
    }
    break;

  case 4:
    if ( pixmap.load ( fn ) ) {
      Rect rect = getDrawRect ();
      Rect mr = getMarginRect ();
      double x = rect.getX()+mr.getX();
      double y = rect.getY()+mr.getY();
      double h=pixmap.height()*0.7;
      double w=pixmap.width()*0.7;

     // Limit the size
      if ( h>34.0 ) {
        w=w*34.0 / h;
        h = 34.0;
      }

      if ( w>mr.getWidth() * 0.8 ) {
        double ratio = mr.getWidth() * 0.8 / w ;
        h *= ratio;
        w *= ratio;
      }

      x+=mr.getWidth()/2.0-w/2.0;
      y+=-30.0-h;
      QRect qrect = QRect (static_cast<int>(x),
                           static_cast<int>(y),
                           static_cast<int>(w),
                           static_cast<int>(h) );
      m_painter->drawPixmap (qrect, pixmap );
    }
    break;

    
  }


  // TODO: Show error if failed to load the image.
}


void
QtViewImp::
drawLatex ( const std::string &eq, int position )
{
  std::map< const std::string, std::string>::iterator it = m_eq_png.find(eq);
  if ( it!=m_eq_png.end() ) {
    drawImage (m_eq_png[eq], position);
  }
  else {
    // Work in the temp_latex directory
    assert(QDir::setCurrent(QString ( m_tmpDirName.c_str()) ) );

    // Generate the filenames. It's unique and based on the current time. Need millisecond accuracy.
    QString current_time = QDateTime::currentDateTime().toString("yyyyMMddhhmmsszzz");
    QString tex_filename = "image"+current_time+".tex";
    QString png_filename = "image"+current_time+".png";
    QString ps_filename  = "image"+current_time+".ps";
    QString dvi_filename = "image"+current_time+".dvi";
    QString tmp_filename = "image"+current_time+".tmp";
    QString aux_filename = "image"+current_time+".aux";
    QString log_filename = "image"+current_time+".log";

    // Command 1 to 3 generate the png file and command 4 remove all temp files
    QString command1 = "latex -interaction=nonstopmode "+tex_filename+" > "+tmp_filename;
    QString command2 = "dvips -q -o "+ps_filename+" "+dvi_filename;
    QString command3 = "gs < /dev/null -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=ppmraw -sOutputFile=- -r150 -q -dNOPAUSE "+ps_filename+" | pnmcrop -white | pnmmargin -white 10 | pnmtopng -interlace - >"+png_filename;
    QString command4 = "rm "+tex_filename+" "+ps_filename+" "+dvi_filename+" "+tmp_filename+" "+aux_filename+" "+log_filename;
    
    // Write the Latex text to file and call the commands to generate the image
    QFile file(tex_filename);
    if (file.open(IO_WriteOnly) ) {
      QTextStream stream(&file);
      // Generate the Latex file ( wither header and ending )
      stream << "\\documentclass{article}\n";
      stream << "\\pagestyle{empty}\n";
      stream << "\\usepackage{xspace,amssymb,amsfonts,amsmath}\n";
      stream << "\\usepackage{mathptmx}\n";
      stream << "\\usepackage{color}\n";
      stream << "\\begin{document}\n";
      stream << "\\begin{displaymath}\n";
      stream << eq.c_str() <<"\n";
      stream << "\\end{displaymath}\n";
      stream << "\\end{document}\n";
      file.close();
      
      system(command1.latin1());
      system(command2.latin1());
      system(command3.latin1());
      system(command4.latin1());
      
      std::string png_fn = png_filename.latin1();
      m_eq_png[eq]=png_fn;
      
      // Make sure return to the original working directory.
      QDir::setCurrent("..");
      drawImage(png_fn, position);
    } else {
      QDir::setCurrent("..");
      // TODO: Show error if failed to open the text file.
    }
  }
}