//! Wrapper for QPainter::drawRect()
void QwtPainter::drawRect( QPainter *painter, const QRectF &rect )
{
const QRectF r = rect;
QRectF clipRect;
const bool deviceClipping = qwtIsClippingNeeded( painter, clipRect );
if ( deviceClipping )
{
if ( !clipRect.intersects( r ) )
return;
if ( !clipRect.contains( r ) )
{
fillRect( painter, r & clipRect, painter->brush() );
painter->save();
painter->setBrush( Qt::NoBrush );
drawPolyline( painter, QPolygonF( r ) );
painter->restore();
return;
}
}
painter->drawRect( r );
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
drawPolyline(g_pointList);
glFlush();
}
/**
* Draws a rotated ellipse arc.
*/
void RS_PainterQt::drawEllipse(const RS_Vector& cp,
double radius1, double radius2,
double angle,
double a1, double a2,
bool reversed) {
QPolygon pa;
createEllipse(pa, cp, radius1, radius2, angle, a1, a2, reversed);
drawPolyline(pa);
}
/*!
Wrapper for QPainter::drawRect()
*/
void QwtPainter::drawRect(QPainter *painter, const QRect &rect)
{
QRect r = d_metricsMap.layoutToDevice(rect, painter);
QRect clipRect;
const bool deviceClipping = needDeviceClipping(painter, d_deviceClipping);
if ( deviceClipping )
clipRect = deviceClipRect();
if ( clipRect.isValid() )
{
if ( !clipRect.intersects(r) )
return;
if ( !clipRect.contains(r) )
{
fillRect(painter, r & clipRect, painter->brush());
int pw = painter->pen().width();
pw = pw % 2 + pw / 2;
QwtPolygon pa(5);
pa.setPoint(0, r.left(), r.top());
pa.setPoint(1, r.right() - pw, r.top());
pa.setPoint(2, r.right() - pw, r.bottom() - pw);
pa.setPoint(3, r.left(), r.bottom() - pw);
pa.setPoint(4, r.left(), r.top());
painter->save();
painter->setBrush(Qt::NoBrush);
drawPolyline(painter, pa);
painter->restore();
return;
}
}
#if QT_VERSION >= 0x040000
if ( painter->pen().style() != Qt::NoPen &&
painter->pen().color().isValid() )
{
// Qt4 adds the pen to the rect, Qt3 not.
int pw = painter->pen().width();
if ( pw == 0 )
pw = 1;
r.setWidth(r.width() - pw);
r.setHeight(r.height() - pw);
}
#endif
painter->drawRect(r);
}
// public static
void kpPixmapFX::drawLine (QImage *image,
int x1, int y1, int x2, int y2,
const kpColor &color, int penWidth,
const kpColor &stippleColor)
{
QPolygon points;
points.append (QPoint (x1, y1));
points.append (QPoint (x2, y2));
drawPolyline (image,
points,
color, penWidth,
stippleColor);
}
/**
* Draws an arc.
*
* @param cx center in x
* @param cy center in y
* @param radius Radius
* @param a1 Angle 1 in rad
* @param a2 Angle 2 in rad
* @param reversed true: clockwise, false: counterclockwise
*/
void RS_PainterQt::drawArc(const RS_Vector& cp, double radius,
double a1, double a2,
bool reversed) {
if(radius<=0.5) {
drawGridPoint(cp);
} else {
#ifdef __APPL1E__
drawArcMac(cp, radius, a1, a2, reversed);
#else
QPolygon pa;
createArc(pa, cp, radius, a1, a2, reversed);
drawPolyline(pa);
#endif
}
}
void QLogicCircuitShapeConnector::paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget)
{
Q_UNUSED(option);
Q_UNUSED(widget);
if (connectionPointAtStart() && connectionPointAtStart()->parentShape()->property("state").toBool()){
painter->setPen(Qt::green);
}
QPen pen(Qt::black);
pen.setWidthF(5);
painter->setPen(pen);
drawPolyline(painter, m_breakPoints);
if (isSelected()){
paintBreakPoints(painter, m_breakPoints);
}
}
/*!
Wrapper for QPainter::drawLine()
*/
void QwtPainter::drawLine(QPainter *painter, int x1, int y1, int x2, int y2)
{
QRect clipRect;
const bool deviceClipping = isClippingNeeded(painter, clipRect);
if ( deviceClipping &&
!(clipRect.contains(x1, y1) && clipRect.contains(x2, y2)) )
{
QwtPolygon pa(2);
pa.setPoint(0, x1, y1);
pa.setPoint(1, x2, y2);
drawPolyline(painter, pa);
return;
}
if ( d_metricsMap.isIdentity() )
{
#if QT_VERSION >= 0x030200 && QT_VERSION < 0x040000
if ( !painter->device()->isExtDev() )
#endif
{
painter->drawLine(x1, y1, x2, y2);
return;
}
}
const QPoint p1 = d_metricsMap.layoutToDevice(QPoint(x1, y1));
const QPoint p2 = d_metricsMap.layoutToDevice(QPoint(x2, y2));
#if QT_VERSION >= 0x030200 && QT_VERSION < 0x040000
if ( painter->device()->isExtDev() )
{
// Strange: the postscript driver of QPrinter adds an offset
// of 0.5 to the start/endpoint when using drawLine, but not
// for lines painted with drawLineSegments.
QwtPolygon pa(2);
pa.setPoint(0, p1);
pa.setPoint(1, p2);
painter->drawLineSegments(pa);
}
else
painter->drawLine(p1, p2);
#else
painter->drawLine(p1, p2);
#endif
}
//! Wrapper for QPainter::drawLine()
void QwtPainter::drawLine( QPainter *painter, const QPointF &p1, const QPointF &p2 )
{
QRectF clipRect;
const bool deviceClipping = qwtIsClippingNeeded( painter, clipRect );
if ( deviceClipping &&
!( clipRect.contains( p1 ) && clipRect.contains( p2 ) ) )
{
QPolygonF polygon;
polygon += p1;
polygon += p2;
drawPolyline( painter, polygon );
return;
}
painter->drawLine( p1, p2 );
}
/*!
Wrapper for QPainter::drawRect()
*/
void QwtPainter::drawRect(QPainter *painter, const QRect &rect)
{
const QRect r = d_metricsMap.layoutToDevice(rect, painter);
QRect clipRect;
const bool deviceClipping = needDeviceClipping(painter, d_deviceClipping);
if ( deviceClipping )
clipRect = deviceClipRect();
if ( clipRect.isValid() )
{
if ( !clipRect.intersects(r) )
return;
if ( !clipRect.contains(r) )
{
fillRect(painter, r & clipRect, painter->brush());
int pw = painter->pen().width();
pw = pw % 2 + pw / 2;
QwtPolygon pa(5);
pa.setPoint(0, r.left(), r.top());
pa.setPoint(1, r.right() - pw, r.top());
pa.setPoint(2, r.right() - pw, r.bottom() - pw);
pa.setPoint(3, r.left(), r.bottom() - pw);
pa.setPoint(4, r.left(), r.top());
painter->save();
painter->setBrush(Qt::NoBrush);
drawPolyline(painter, pa);
painter->restore();
return;
}
}
painter->drawRect(r);
}
void MapBox::createMenus()
{
QAction * menuItem;
QMenu * subMenuItem;
m_popupMenu = new QMenu(this);
m_popupMenuMapObject = new QMenu(this);
//**************************************************************
// MapObject-specific context menu. The map object is in m_lastClickedMapObject.
subMenuItem = m_popupMenuMapObject->addMenu(tr("MapObject"));
menuItem = subMenuItem->addAction(tr("Remove"));
connect(menuItem, SIGNAL(triggered()),
this, SLOT(removeMapObject()));
//**************************************************************
/*
// These are gread for testing, but not really what we want in
// an example application.
// We should probably creating a testing branch which tracks
// the master branch and has various "test enabled" versions
// of the examples at some point anyhow.
subMenuItem = m_popupMenuMapObject->addMenu(tr("Spawn stuff"));
m_popupMenu->addMenu(subMenuItem);
menuItem = subMenuItem->addAction(tr("Items near the dateline"));
connect(menuItem, SIGNAL(triggered()),
this, SLOT(demo1()));
menuItem = subMenuItem->addAction(tr("Regular grid of items"));
connect(menuItem, SIGNAL(triggered()),
this, SLOT(demo2()));
menuItem = subMenuItem->addAction(tr("Clusters"));
connect(menuItem, SIGNAL(triggered()),
this, SLOT(demo3()));
*/
//**************************************************************
subMenuItem = m_popupMenuMapObject->addMenu(tr("Marker"));
m_popupMenu->addMenu(subMenuItem);
menuItem = subMenuItem->addAction(tr("Set marker"));
connect(menuItem, SIGNAL(triggered()),
this, SLOT(drawPixmap()));
menuItem = subMenuItem->addAction(tr("Remove markers"));
connect(menuItem, SIGNAL(triggered()),
this, SLOT(removePixmaps()));
menuItem = subMenuItem->addAction(tr("Select objects"));
connect(menuItem, SIGNAL(triggered()),
this, SLOT(selectObjects()));
//**************************************************************
subMenuItem = m_popupMenu->addMenu(tr("Draw"));
m_popupMenu->addMenu(subMenuItem);
menuItem = subMenuItem->addAction(tr("Rectangle"));
connect(menuItem, SIGNAL(triggered()),
this, SLOT(drawRect()));
menuItem = subMenuItem->addAction(tr("Polyline"));
connect(menuItem, SIGNAL(triggered()),
this, SLOT(drawPolyline()));
menuItem = subMenuItem->addAction(tr("Polygon"));
connect(menuItem, SIGNAL(triggered()),
this, SLOT(drawPolygon()));
menuItem = subMenuItem->addAction(tr("Circle"));
connect(menuItem, SIGNAL(triggered()),
this, SLOT(drawCircle()));
menuItem = subMenuItem->addAction(tr("Text"));
connect(menuItem, SIGNAL(triggered()),
this, SLOT(drawText()));
//**************************************************************
subMenuItem = m_popupMenuMapObject->addMenu(tr("Route"));
m_popupMenu->addMenu(subMenuItem);
menuItem = subMenuItem->addAction(tr("Calculate route"));
connect(menuItem, SIGNAL(triggered()),
this, SLOT(calcRoute()));
//**************************************************************
subMenuItem = m_popupMenuMapObject->addMenu(tr("Coordinates"));
m_popupMenu->addMenu(subMenuItem);
menuItem = subMenuItem->addAction(tr("Capture"));
connect(menuItem, SIGNAL(triggered()),
this, SLOT(captureCoordinates()));
connect(menuItem, SIGNAL(triggered()),
m_coordControlDialog, SLOT(show()));
menuItem = subMenuItem->addAction(tr("Go to"));
connect(menuItem, SIGNAL(triggered()),
m_coordControlDialog, SLOT(show()));
//**************************************************************
subMenuItem = m_popupMenuMapObject->addMenu(tr("Tests"));
m_popupMenu->addMenu(subMenuItem);
menuItem = subMenuItem->addAction(tr("Dateline"));
connect(menuItem, SIGNAL(triggered()),
this, SLOT(testDateline()));
}
// draw spec only if rectanglar frame is defined.
void SpecView::drawSpec(float *data, int npts, int step, double vscale, double yoff, int fx, int fy, int fw, int fh, int color) {
if(!data || npts < 2) return;
if(!canDrawSpec(fx,fy,fw,fh)) return;
drawPolyline(data, npts, step, voxx, voxy, voxw, voxh, color, false, vscale, yoff);
}
void KivioShapePainter::drawShape( KivioShape *pShape, float x, float y, float w, float h )
{
KivioShapeData *pShapeData;
m_x = x;
m_y = y;
m_w = w;
m_h = h;
m_pShape = pShape;
pShapeData = pShape->shapeData();
switch( pShapeData->shapeType() )
{
case KivioShapeData::kstArc:
drawArc();
break;
case KivioShapeData::kstPie:
drawPie();
break;
case KivioShapeData::kstLineArray:
drawLineArray();
break;
case KivioShapeData::kstPolyline:
drawPolyline();
break;
case KivioShapeData::kstPolygon:
drawPolygon();
break;
case KivioShapeData::kstBezier:
drawBezier();
break;
case KivioShapeData::kstRectangle:
drawRectangle();
break;
case KivioShapeData::kstRoundRectangle:
drawRoundRectangle();
break;
case KivioShapeData::kstEllipse:
drawEllipse();
break;
case KivioShapeData::kstOpenPath:
drawOpenPath();
break;
case KivioShapeData::kstClosedPath:
drawClosedPath();
break;
case KivioShapeData::kstTextBox:
drawTextBox();
break;
case KivioShapeData::kstNone:
default:
break;
}
}
/**
* Draws an arc which starts / ends exactly at the given coordinates.
*
* @param cx center in x
* @param cy center in y
* @param radius Radius
* @param a1 Angle 1 in rad
* @param a2 Angle 2 in rad
* @param x1 startpoint x
* @param y1 startpoint y
* @param x2 endpoint x
* @param y2 endpoint y
* @param reversed true: clockwise, false: counterclockwise
*/
void RS_PainterQt::drawArc(const RS_Vector& cp, double radius,
double a1, double a2,
const RS_Vector& p1, const RS_Vector& p2,
bool reversed) {
/*
QPainter::drawArc(cx-radius, cy-radius,
2*radius, 2*radius,
a1*16, (a2-a1)*16);
*/
if(radius<=0.5) {
drawGridPoint(cp);
} else {
#ifdef __APPLE1__
drawArcMac(cp, radius, a1, a2, reversed);
#else
int cix; // Next point on circle
int ciy; //
double aStep; // Angle Step (rad)
double a; // Current Angle (rad)
double linStep; // linear step (pixels)
if (drawingMode==RS2::ModePreview) {
linStep = 20.0;
} else {
linStep = 6.0;
}
if (fabs(linStep/radius)<=1.0) {
aStep=asin(linStep/radius);
} else {
aStep=1.0;
}
if (aStep<0.05) {
aStep = 0.05;
}
if(!reversed) {
// Arc Counterclockwise:
if(a1>a2-1.0e-10) {
a2+=2*M_PI;
}
//moveTo(toScreenX(p1.x), toScreenY(p1.y));
QPolygon pa;
int i=0;
pa.resize(i+1);
pa.setPoint(i++, toScreenX(p1.x), toScreenY(p1.y));
for(a=a1+aStep; a<=a2; a+=aStep) {
cix = toScreenX(cp.x+cos(a)*radius);
ciy = toScreenY(cp.y-sin(a)*radius);
//lineTo(cix, ciy);
pa.resize(i+1);
pa.setPoint(i++, cix, ciy);
}
//lineTo(toScreenX(p2.x), toScreenY(p2.y));
pa.resize(i+1);
pa.setPoint(i++, toScreenX(p2.x), toScreenY(p2.y));
drawPolyline(pa);
} else {
// Arc Clockwise:
if(a1<a2+1.0e-10) {
a2-=2*M_PI;
}
QPolygon pa;
int i=0;
pa.resize(i+1);
pa.setPoint(i++, toScreenX(p1.x), toScreenY(p1.y));
//moveTo(toScreenX(p1.x), toScreenY(p1.y));
for(a=a1-aStep; a>=a2; a-=aStep) {
cix = toScreenX(cp.x+cos(a)*radius);
ciy = toScreenY(cp.y-sin(a)*radius);
//lineTo(cix, ciy);
pa.resize(i+1);
pa.setPoint(i++, cix, ciy);
}
//lineTo(toScreenX(p2.x), toScreenY(p2.y));
pa.resize(i+1);
pa.setPoint(i++, toScreenX(p2.x), toScreenY(p2.y));
drawPolyline(pa);
}
#endif
}
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent)
{
setupUi(this);
setWindowTitle(tr("GD CAD"));
newFile();
qApp->installEventFilter(this);
<<<<<<< HEAD
connect(ui->pointButton, SIGNAL(clicked()), this, SLOT(drawPoint()));
connect(ui->lineButton, SIGNAL(clicked()), this, SLOT(drawLine()));
connect(ui->circleButton, SIGNAL(clicked()), this, SLOT(drawCircle()));
connect(ui->ellipseButton, SIGNAL(clicked()), this, SLOT(drawEllipse()));
connect(ui->arcButton, SIGNAL(clicked()),this, SLOT(drawArc()));
connect(ui->polylineButton, SIGNAL(clicked()),this, SLOT(drawPolyline()));
connect(ui->actionPoints, SIGNAL(triggered()), this, SLOT(drawPoint()));
connect(ui->actionLine, SIGNAL(triggered()), this, SLOT(drawLine()));
connect(ui->actionCircle, SIGNAL(triggered()), this, SLOT(drawCircle()));
connect(ui->actionEllipse, SIGNAL(triggered()), this, SLOT(drawEllipse()));
connect(ui->actionArc, SIGNAL(triggered()), this, SLOT(drawArc()));
connect(ui->actionPolyline, SIGNAL(triggered()), this, SLOT(drawPolyline()));
addToolbars();
connect(ui->actionNew, SIGNAL(triggered()), this, SLOT(newFile()));
connect(ui->actionQuit, SIGNAL(triggered()), this, SLOT(close()));
connect(ui->actionPrint, SIGNAL(triggered()), this, SLOT(filePrint()));
