//virtual
bool
Zoomer::accept( QPolygon &pa ) const
{
if ( pa.count() < 2 )
return false;
QRect rect = QRect( pa[0], pa[int( pa.count() ) - 1] );
rect = rect.normalized();
if ( rect.width() < 2 && rect.height() < 2 )
return false;
pa.resize( 2 );
const QRectF& rc = pickArea().boundingRect(); // view rect
if ( rect.width() < minX ) {
// make a virtical line
pa[ 0 ] = QPoint( rc.left(), rect.top() );
pa[ 1 ] = QPoint( rc.right(), rect.bottom() );
return true;
} else if ( rect.height() < minY ) {
// make a horizontal line
pa[ 0 ] = QPoint( rect.left(), rc.top() );
pa[ 1 ] = QPoint( rect.right(), rc.bottom() );
} else {
pa[ 0 ] = rect.topLeft();
pa[ 1 ] = rect.bottomRight();
}
return true;
}
inline void GraphPolygonClipper::addPoint(
QPolygon &pa, uint pos, const QPoint &point) const
{
if ( uint(pa.size()) <= pos )
pa.resize(pos + 5);
pa.setPoint(pos, point);
}
void GraphPolygonClipper::clipEdge(Edge edge,
const QPolygon &pa, QPolygon &cpa) const
{
if ( pa.count() == 0 )
{
cpa.resize(0);
return;
}
unsigned int count = 0;
QPoint p1 = pa.point(0);
if ( insideEdge(p1, edge) )
addPoint(cpa, count++, p1);
const uint nPoints = pa.size();
for ( uint i = 1; i < nPoints; i++ )
{
const QPoint p2 = pa.point(i);
if ( insideEdge(p2, edge) )
{
if ( insideEdge(p1, edge) )
addPoint(cpa, count++, p2);
else
{
addPoint(cpa, count++, intersectEdge(p1, p2, edge));
addPoint(cpa, count++, p2);
}
}
else
{
if ( insideEdge(p1, edge) )
addPoint(cpa, count++, intersectEdge(p1, p2, edge));
}
p1 = p2;
}
cpa.resize(count);
}
bool QwtPlotZoomer::accept( QPolygon &pa ) const
{
if ( pa.count() < 2 )
return false;
QRect rect = QRect( pa.first(), pa.last() );
rect = rect.normalized();
const int minSize = 2;
if ( rect.width() < minSize && rect.height() < minSize )
return false;
const int minZoomSize = 11;
const QPoint center = rect.center();
rect.setSize( rect.size().expandedTo( QSize( minZoomSize, minZoomSize ) ) );
rect.moveCenter( center );
pa.resize( 2 );
pa[0] = rect.topLeft();
pa[1] = rect.bottomRight();
return true;
}
static void addPoint(QPolygon &a, const QPoint &p)
{
uint n = a.size();
a.resize(n + 1);
a.setPoint(n, p);
}
/**
* 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
}
}
// motif arrows look the same whether they are used or not
// is this correct?
static void qDrawMotifArrow(QPainter *p, Qt::ArrowType type, bool down,
int x, int y, int w, int h,
const QPalette &pal, bool)
{
QPolygon bFill; // fill polygon
QPolygon bTop; // top shadow.
QPolygon bBot; // bottom shadow.
QPolygon bLeft; // left shadow.
QTransform matrix; // xform matrix
bool vertical = type == Qt::UpArrow || type == Qt::DownArrow;
bool horizontal = !vertical;
int dim = w < h ? w : h;
int colspec = 0x0000; // color specification array
if (dim < 2) // too small arrow
return;
if (dim > 3) {
if (dim > 6)
bFill.resize(dim & 1 ? 3 : 4);
bTop.resize((dim/2)*2);
bBot.resize(dim & 1 ? dim + 1 : dim);
bLeft.resize(dim > 4 ? 4 : 2);
bLeft.putPoints(0, 2, 0,0, 0,dim-1);
if (dim > 4)
bLeft.putPoints(2, 2, 1,2, 1,dim-3);
bTop.putPoints(0, 4, 1,0, 1,1, 2,1, 3,1);
bBot.putPoints(0, 4, 1,dim-1, 1,dim-2, 2,dim-2, 3,dim-2);
for(int i=0; i<dim/2-2 ; i++) {
bTop.putPoints(i*2+4, 2, 2+i*2,2+i, 5+i*2, 2+i);
bBot.putPoints(i*2+4, 2, 2+i*2,dim-3-i, 5+i*2,dim-3-i);
}
if (dim & 1) // odd number size: extra line
bBot.putPoints(dim-1, 2, dim-3,dim/2, dim-1,dim/2);
if (dim > 6) { // dim>6: must fill interior
bFill.putPoints(0, 2, 1,dim-3, 1,2);
if (dim & 1) // if size is an odd number
bFill.setPoint(2, dim - 3, dim / 2);
else
bFill.putPoints(2, 2, dim-4,dim/2-1, dim-4,dim/2);
}
}
else {
if (dim == 3) { // 3x3 arrow pattern
bLeft.setPoints(4, 0,0, 0,2, 1,1, 1,1);
bTop .setPoints(2, 1,0, 1,0);
bBot .setPoints(2, 1,2, 2,1);
}
else { // 2x2 arrow pattern
bLeft.setPoints(2, 0,0, 0,1);
bTop .setPoints(2, 1,0, 1,0);
bBot .setPoints(2, 1,1, 1,1);
}
}
if (type == Qt::UpArrow || type == Qt::LeftArrow) {
matrix.translate(x, y);
if (vertical) {
matrix.translate(0, h - 1);
matrix.rotate(-90);
} else {
matrix.translate(w - 1, h - 1);
matrix.rotate(180);
}
if (down)
colspec = horizontal ? 0x2334 : 0x2343;
else
colspec = horizontal ? 0x1443 : 0x1434;
}
else if (type == Qt::DownArrow || type == Qt::RightArrow) {
matrix.translate(x, y);
if (vertical) {
matrix.translate(w-1, 0);
matrix.rotate(90);
}
if (down)
colspec = horizontal ? 0x2443 : 0x2434;
else
colspec = horizontal ? 0x1334 : 0x1343;
}
const QColor *cols[5];
cols[0] = 0;
cols[1] = &pal.button().color();
cols[2] = &pal.mid().color();
cols[3] = &pal.light().color();
cols[4] = &pal.dark().color();
#define CMID *cols[(colspec>>12) & 0xf]
#define CLEFT *cols[(colspec>>8) & 0xf]
#define CTOP *cols[(colspec>>4) & 0xf]
#define CBOT *cols[colspec & 0xf]
QPen savePen = p->pen(); // save current pen
QBrush saveBrush = p->brush(); // save current brush
QTransform wxm = p->transform();
QPen pen(Qt::NoPen);
const QBrush &brush = pal.brush(QPalette::Button);
p->setPen(pen);
p->setBrush(brush);
p->setTransform(matrix, true); // set transformation matrix
p->drawPolygon(bFill); // fill arrow
p->setBrush(Qt::NoBrush); // don't fill
p->setPen(CLEFT);
p->drawLines(bLeft);
p->setPen(CTOP);
p->drawLines(bTop);
p->setPen(CBOT);
p->drawLines(bBot);
p->setTransform(wxm);
p->setBrush(saveBrush); // restore brush
p->setPen(savePen); // restore pen
#undef CMID
#undef CLEFT
#undef CTOP
#undef CBOT
}
void RS_Painter::createArc(QPolygon& pa,
const RS_Vector& cp, double radius,
double a1, double a2,
bool reversed) {
if (radius<1.0e-6) {
RS_DEBUG->print(RS_Debug::D_WARNING,
"RS_Painter::createArc: invalid radius: %f", radius);
return;
}
int cix; // Next point on circle
int ciy; //
double aStep; // Angle Step (rad)
double a; // Current Angle (rad)
if(fabs(2.0/radius)<=1.0) {
aStep=asin(2.0/radius);
} else {
aStep=1.0;
}
aStep=aStep/2.0;
//if (aStep<0.05) {
// aStep = 0.05;
//}
// less than a pixel long lines:
//if (radius*aStep<1.0) {
// aStep =
//}
//QPointArray pa;
int i=0;
pa.resize(i+1);
pa.setPoint(i++, toScreenX(cp.x+cos(a1)*radius),
toScreenY(cp.y-sin(a1)*radius));
//moveTo(toScreenX(cp.x+cos(a1)*radius),
// toScreenY(cp.y-sin(a1)*radius));
if(!reversed) {
// Arc Counterclockwise:
if(a1>a2-1.0e-10) {
a2+=2*M_PI;
}
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);
}
} else {
// Arc Clockwise:
if(a1<a2+1.0e-10) {
a2-=2*M_PI;
}
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(cp.x+cos(a2)*radius),
// toScreenY(cp.y-sin(a2)*radius));
pa.resize(i+1);
pa.setPoint(i++,
toScreenX(cp.x+cos(a2)*radius),
toScreenY(cp.y-sin(a2)*radius));
//drawPolyline(pa);
}