Qdriver.cpp

#include "QDisplayDialog.h"
#include "Qdriver.h"
#include <QPicture>
#include <QPainter>
#include <QPainterPath>
#include <QPen>
#include <QColor>
#include <iostream>
#include <math.h>


#define QDRIVER_MAXLOGICAL_COORDINATE 10000

//
// Locally defined utility routines
//
QColor getColorRef(int iColor)
{

    switch(iColor)
    {
    case UCdriver::BLACK         : return QColor(0,0,0);
    case UCdriver::DARK_GREY     : return QColor(128,128,128);
    case UCdriver::LIGHT_GREY    : return QColor(192,192,192);
    case UCdriver::BLUE          : return QColor(0,0,255);
    case UCdriver::LIGHT_BLUE    : return QColor(130,130,255);
    case UCdriver::GREEN         : return QColor(0,255,0);
    case UCdriver::LIGHT_GREEN   : return QColor(192,192,192);
    case UCdriver::CYAN          : return QColor(0,255,255);
    case UCdriver::LIGHT_CYAN    : return QColor(128,255,255);
    case UCdriver::RED           : return QColor(255,0,0);
    case UCdriver::MAGENTA       : return QColor(255,0,255);
    case UCdriver::LIGHT_MAGENTA : return QColor(255,128,255);
    case UCdriver::ORANGE        : return QColor(255,128,64);
    case UCdriver::YELLOW        : return QColor(255,255,0);
    case UCdriver::WHITE         : return QColor(255,255,255);
    }
    return QColor(0,0,0);
}

Qdriver::Qdriver()
{
    graphicsMetaData     = new QPicture();
    qDisplayDialog       = new QDisplayDialog();
    qPainter             = new QPainter();
    qPen                 = new QPen();
    qFont                = new QFont("Helvetica");
    qBrush               = new QBrush();
    qFontMetrics         = 0;
    setMaxLogicalCoordinate(QDRIVER_MAXLOGICAL_COORDINATE);
    qPainter->begin(graphicsMetaData);   
    qPainter->setRenderHint(QPainter::Antialiasing, true);
    qPainter->setClipping(true);
    qPainter->setClipRegion(QRegion(0,0,maxLogicalCoordinate,maxLogicalCoordinate),Qt::ReplaceClip);
//
//  Pen style defaults
//
    qPen->setJoinStyle(Qt::RoundJoin);
    setDriverTypeName("QDriver");
}

Qdriver::~Qdriver()
{
    if(qDisplayDialog   != 0) delete qDisplayDialog;
    if(qPen             != 0) delete qPen;
    if(qPainter         != 0) delete qPainter;
    if(graphicsMetaData != 0) delete graphicsMetaData;
    if(qFont            != 0) delete qFont;
    if(qBrush           != 0) delete qBrush;
    if(qFontMetrics     != 0) delete qFontMetrics;
}


void Qdriver::setMaxLogicalCoordinate(long maxCoord)
{
    maxLogicalCoordinate = maxCoord;
}

//
// User_pattern ignored for now
//
void Qdriver::setPenDashAndColor(int dash_pattern, unsigned user_pattern, int color, double *rgb)
{

    if(color != UCdriver::USER_RGB)
    {qPen->setColor(getColorRef(color));}
    else
    {qPen->setColor(QColor(long(rgb[0]),long(rgb[1]),long(rgb[2])));}
    
    switch(dash_pattern)
    {
    case UCdriver::SOLID           : qPen->setStyle(Qt::SolidLine);       break;
    case UCdriver::DASH            : qPen->setStyle(Qt::DashLine);        break;
    case UCdriver::DOTS            : qPen->setStyle(Qt::DotLine);         break;
    case UCdriver::DASH_DOT        : qPen->setStyle(Qt::DashDotLine);     break;
    case UCdriver::DASH_DOUBLE_DOT : qPen->setStyle(Qt::DashDotDotLine);  break;
    case UCdriver::DOUBLE_DASH     : qPen->setStyle(Qt::DashLine);        break;
    case UCdriver::USER_DASH       : qPen->setStyle(Qt::SolidLine);       break;
    default : qPen->setStyle(Qt::SolidLine); 
    }

    //
    // Scale the dash pattern
    //
    
    QVector<double> qVector(qPen->dashPattern());
    for(int i = 0; i < qVector.size(); i++)
    {
    qVector[i] *= 3.0;
    }
    
    qPen->setDashPattern(qVector);
    qPainter->setPen(*qPen);
}
    
void Qdriver::setBrushColor(int color, double *rgb)
{

    if(color != UCdriver::USER_RGB)
    {qBrush->setColor(getColorRef(color));}
    else
    {qBrush->setColor(QColor(long(rgb[0]),long(rgb[1]),long(rgb[2])));}
}

void Qdriver::setFont(char* font, double size)
{
    double defaultTextScaling = 0.02;
 
    if(qFontMetrics != 0) delete qFontMetrics;
 
    if(font != 0)
    {
      if(qFont != 0) delete qFont;
      qFont      =   new QFont(font);
    }
 
    if(fabs(size) != 0.0) 
    {
 qFont->setPointSize((int)(maxLogicalCoordinate*size));
    } 
    else 
    {
 qFont->setPointSize((int)(maxLogicalCoordinate*defaultTextScaling));
    }
 
     qFont->setStyleStrategy(QFont::ForceOutline);
     qFont->setStyleHint(QFont::Helvetica);
     qFontMetrics =  new QFontMetrics(*qFont);
 
     qPainter->setFont(*qFont);  
}
    
void Qdriver::setImageOutputQuality(int quality)
{
    qDisplayDialog->setImageOutputQuality(quality);
}
    
void Qdriver::lines(double *x, double *y, long npoints, int dash_pattern,
             unsigned user_pattern, double width, int color, double *rgb)
{
    setPenDashAndColor(dash_pattern,user_pattern,color,rgb);
    qPen->setWidth((int)(maxLogicalCoordinate*width));
    

    QVector<QPointF> pointPairs(2*npoints);
    for(int i = 0; i < npoints-1; i++)
    {
        pointPairs[2*i].setX(x[i]*maxLogicalCoordinate);
        pointPairs[2*i].setY((1.0-y[i])*maxLogicalCoordinate);
        pointPairs[2*i+1].setX(x[i+1]*maxLogicalCoordinate);
        pointPairs[2*i+1].setY((1.0-y[i+1])*maxLogicalCoordinate);
    }

    qPainter->drawLines(pointPairs);
}
 
void Qdriver::line(double x1, double y1, double x2, double y2, int dash_pattern, 
             unsigned user_pattern, double width, int color, double *rgb)
{
    setPenDashAndColor(dash_pattern,user_pattern,color,rgb);
    qPen->setWidth((int)(maxLogicalCoordinate*width));
    
    qPainter->drawLine(QLineF(maxLogicalCoordinate*x1,maxLogicalCoordinate*(1.0-y1),
    maxLogicalCoordinate*x2,maxLogicalCoordinate*(1.0-y2)));
} 

void Qdriver::point(double x, double y, char p, char *font, double size,
             int color, double *rgb)
{
    points(&x, &y, 1, p, font,size, color, rgb);
}

void Qdriver::points(double *X, double *Y, long np, char p, char *font,
              double size, int color, double *rgb)
{
     setFont(font,size);
 
     setBrushColor(color,rgb);
     qBrush->setStyle(Qt::SolidPattern);
     qPainter->setPen(Qt::NoPen);
     qPainter->setBrush(*qBrush);
     
     QPainterPath path;

     char s[] = {'A','\0'};
     s[0] = p;
     
     QRect qBoundRect =  qFontMetrics->boundingRect(s);  
     int xShift  = (int)(((1.0)*qBoundRect.width())/2.0); 
     int yShift  = (int)(((-1.0)*qBoundRect.height())/2.0);
     
     for(long i = 0; i < np; i++)
     {
     path.addText(QPointF(X[i]*maxLogicalCoordinate - xShift,maxLogicalCoordinate*(1.0-Y[i]) - yShift), *qFont, s);
     }
     qPainter->drawPath(path); 
}

void Qdriver::text(double x, double y, char *s, char *font, double size,
            double rotation, double horiz_just, double vert_just,
            int color, double *rgb)
{
     setFont(font,size);
    
     setBrushColor(color,rgb);
     qBrush->setStyle(Qt::SolidPattern);
     qPainter->setPen(Qt::NoPen);
     qPainter->setBrush(*qBrush);
     
     QRect qBoundRect =  qFontMetrics->boundingRect(s);  
     int xShift  = (int)(((horiz_just + 1.0)*qBoundRect.width())/2.0); 
     int yShift  = (int)(((vert_just  - 1.0)*qBoundRect.height())/2.0);

     qPainter->save();
     qPainter->translate(QPointF(x*maxLogicalCoordinate - xShift ,maxLogicalCoordinate*(1.0-y) - yShift));
     qPainter->rotate(rotation);
     QPainterPath path;
     path.addText(QPointF(0,0), *qFont, s);
     qPainter->drawPath(path);
     qPainter->restore();
   
}
void Qdriver::region(double *X, double *Y, long npoints, double *RGB)
{
    QPointF* points = new QPointF[npoints];
    for(long i = 0; i < npoints; i++)
    {
      points[i].setX(X[i]*maxLogicalCoordinate);
      points[i].setY(maxLogicalCoordinate*(1.0-Y[i]));
    }
    qBrush->setColor(QColor((int)RGB[0],(int)RGB[1],(int)RGB[2]));
    qBrush->setStyle(Qt::SolidPattern);
    qPainter->setBrush(*qBrush);
    qPainter->drawPolygon(points, npoints);
}

void  Qdriver::frame()
{
     qPainter->end();  
     qDisplayDialog->setGraphicsMetaData(graphicsMetaData,maxLogicalCoordinate); 
     qDisplayDialog->exec(); 
     qPainter->begin(graphicsMetaData);                 
}



     /* 
      * drawing using the drawText routine ...
      * 
 qPainter->save();
 qPainter->translate(QPointF(x*maxLogicalCoordinate,maxLogicalCoordinate*(1.0-y)));
 qPainter->rotate(rotation);
 qPainter->drawText(QPointF(0,0),s);
     qPainter->restore();
     */

---