C++ QLineF函数代码示例

void Bracket::draw(QPainter* painter) const
      {
      if (subtype() == BRACKET_AKKOLADE) {
            painter->setPen(Qt::NoPen);
            painter->setBrush(QBrush(curColor()));
            painter->drawPath(path);
            }
      else if (subtype() == BRACKET_NORMAL) {
            qreal h = 2 * h2 + yoff;
            qreal _spatium = spatium();
            qreal w = score()->styleS(ST_bracketWidth).val() * _spatium;
            QPen pen(curColor(), w, Qt::SolidLine, Qt::FlatCap);
            painter->setPen(pen);
            qreal bd   = _spatium * .25;
            painter->drawLine(QLineF(0.0, -bd, 0.0, h + bd));
            int idx = score()->symIdx();
            qreal mags = 1.0;
            qreal x    =  -w * .5;
            qreal y1   = -bd;
            qreal y2   = h + bd;
            symbols[idx][brackettipsRightUp].draw(painter,   mags, QPointF(x, y1));
            symbols[idx][brackettipsRightDown].draw(painter, mags, QPointF(x, y2));
            }
      }

void ItemCircleAnimation::setupGuides()
{
    int x = 0;
    int y = 20;

    this->qtGuide1 = new GuideCircle(QRectF(x, y, 260, 260), -36, 342);
    this->currGuide = 0;
    new GuideLine(QPointF(x + 240, y + 268), this->qtGuide1);
    new GuideLine(QPointF(x + 265, y + 246), this->qtGuide1);
    new GuideLine(QPointF(x + 158, y + 134), this->qtGuide1);
    new GuideLine(QPointF(x + 184, y + 109), this->qtGuide1);
    new GuideLine(QPointF(x + 160, y +  82), this->qtGuide1);
    new GuideLine(QPointF(x +  77, y + 163), this->qtGuide1); // T-top
    new GuideLine(QPointF(x + 100, y + 190), this->qtGuide1);
    new GuideLine(QPointF(x + 132, y + 159), this->qtGuide1);
    new GuideLine(QPointF(x + 188, y + 211), this->qtGuide1);
    new GuideCircle(QRectF(x + 30, y + 30, 200, 200), -30, 336, GuideCircle::CW, this->qtGuide1);
    new GuideLine(QPointF(x + 238, y + 201), this->qtGuide1);

    y = 30;
    this->qtGuide2 = new GuideCircle(QRectF(x + 30, y + 30, 200, 200), 135, 270, GuideCircle::CCW);
    new GuideLine(QPointF(x + 222, y + 38), this->qtGuide2);
    new GuideCircle(QRectF(x, y, 260, 260), 135, 270, GuideCircle::CW, this->qtGuide2);
    new GuideLine(QPointF(x + 59, y + 59), this->qtGuide2);

    x = 115;
    y = 10;
    this->qtGuide3 = new GuideLine(QLineF(x, y, x + 30, y));
    new GuideLine(QPointF(x + 30, y + 170), this->qtGuide3);
    new GuideLine(QPointF(x, y + 170), this->qtGuide3);
    new GuideLine(QPointF(x, y), this->qtGuide3);

    this->qtGuide1->setFence(QRectF(0, 0, 800, 600));
    this->qtGuide2->setFence(QRectF(0, 0, 800, 600));
    this->qtGuide3->setFence(QRectF(0, 0, 800, 600));
}

VLCStatsView::VLCStatsView( QWidget *parent ) : QGraphicsView( parent )
{
    QColor history(0, 0, 0, 255),
        total(237, 109, 0, 160),
        content(109, 237, 0, 160);

    scale( 1.0, -1.0 ); /* invert our Y axis */
    setOptimizationFlags( QGraphicsView::DontAdjustForAntialiasing );
    setAlignment( Qt::AlignLeft );
    setVerticalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
    setHorizontalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
    viewScene = new QGraphicsScene( this );
    historyShape = viewScene->addPolygon( QPolygonF(), QPen(Qt::NoPen),
                                             QBrush(history) );
    totalbitrateShape = viewScene->addPolygon( QPolygonF(), QPen(Qt::NoPen),
                                           QBrush(total) );
    setScene( viewScene );
    reset();

    QPen linepen( Qt::DotLine );
    linepen.setBrush( QBrush( QColor( 33, 33, 33 ) ) );
    for ( int i=0; i<3; i++ )
        rulers[i] = viewScene->addLine( QLineF(), linepen );
}

double CanvasMode_EditSpiral::computeRealAngle(double angle, bool fromDia)
{
	PageItem *currItem = m_doc->m_Selection->itemAt(0);
	double ret = angle;
	int rev = static_cast<int>(angle / 360.0);
	double part = angle - (rev * 360);
	QTransform bb;
	bb.scale(currItem->width() / currItem->height(), 1.0);
	QLineF inp = QLineF(QPointF(currItem->width() / 2.0, currItem->height() / 2.0), QPointF(currItem->width(), currItem->height() / 2.0));
	inp.setAngle(part);
	if (fromDia)
	{
		QLineF res = bb.map(inp);
		ret = res.angle();
	}
	else
	{
		QTransform bt = bb.inverted();
		QLineF res = bt.map(inp);
		ret = res.angle();
	}
	ret += rev * 360;
	return ret;
}

// ============================================================================
/// Renders
void ControlSurface::render(QPainter& painter, const QRectF&, const RenderingOptions& )
{
	painter.save();
		painter.setTransform( body()->transform(), true );
		painter.setPen( Qt::black );
		
		double angle = ( _value*_step + _inclination ) *parent()->orientation();
		double wx = cos( angle ) * _width/2;
		double wy = sin( angle ) * _width/2;
		
		painter.drawLine( QLineF( _position.x()-wx, _position.y()-wy, _position.x()+wx, _position.y()+wy ) );
		
	painter.restore();
	
	// draw force (DEBUG )
	/*
	double fs = 500 ; // force scale
	QPointF wf = aerodynamicForce() / fs;
	const b2Vec2& pos = body()->b2body()->GetWorldPoint( point2vec( _position ) );
	
	painter.setPen( Qt::green );
	painter.drawLine( QLineF( pos.x, pos.y, pos.x + wf.x(), pos.y + wf.y() ) );
	*/
}

void KiviatView::redrawAll()
{
   //Delete markers and axes,keep the captions
   qDeleteAll(markers);
   qDeleteAll(axes);
   markers.clear();
   axes.clear();

   setupAxesCaptions();

   //Paint Axes and adjust label position
   for(int i=0; i<axisCount; i++)
   {
      //Draw the axis-line
      QGraphicsLineItem * line= scene.addLine(QLineF(QPointF(0,0),calcPosition(i,1)));
      line->setZValue(1);
      axes.push_back(line);

      // Why Position 1.08?  Pos 1.0 means end of axis
      // label is positioned a litte bit further away from center
      // also needed in setAxisLabel
      QPointF lPos = calcPosition(i, 1.08);
      axisLabels[i]->setPos(QPoint(0,0));
      axisLabels[i]->moveBy(lPos.x(),lPos.y());

      // If the axis is on the left side, the text has to be moved to the left
      if( axisLabels[i]->pos().x()<0 )
         axisLabels[i]->moveBy(- axisLabels[i]->boundingRect().width(),0);
   }

   //Call setMarkerCount with current count, to paint them
   setMarkerCount(prop_markerCount);

   redrawData();

}

void LineItem::creationPolygonChanged(View::CreationEvent event) {
  if (event == View::EscapeEvent) {
    ViewItem::creationPolygonChanged(event);
    return;
  }

  if (event == View::MousePress) {
    const QPolygonF poly = mapFromScene(view()->creationPolygon(View::MousePress));
    setPos(poly.first().x(), poly.first().y());
    setViewRect(QRectF(0.0, -sizeOfGrip().height()*0.5, 0.0, sizeOfGrip().height()));
    view()->scene()->addItem(this);
    return;
  }

  if (event == View::MouseMove) {
    const QPolygonF poly = mapFromScene(view()->creationPolygon(View::MouseMove));
    if (!rect().isEmpty()) {
      rotateTowards(line().p2(), poly.last());
    }
    QRectF r = rect();
    r.setSize(QSizeF(QLineF(line().p1(), poly.last()).length(), r.height()));
    setViewRect(r);
    return;
  }

  if (event == View::MouseRelease) {
    const QPolygonF poly = mapFromScene(view()->creationPolygon(View::MouseRelease));
    view()->disconnect(this, SLOT(deleteLater())); //Don't delete ourself
    view()->disconnect(this, SLOT(creationPolygonChanged(View::CreationEvent)));
    view()->setMouseMode(View::Default);
    updateViewItemParent();
    _created = true;
    emit creationComplete();
    return;
  }
}

QPointF SCgNode::cross(const QPointF &from, float dot) const
{
    QPointF p(0.f, 0.f);

    if (!mContentVisible)
    {
        QVector2D vec(from - scenePos());
        p = vec.normalized().toPointF() * (mSize.width() / 2.f + 5.f);
    }else
    {

        // count intersection with content border
        QPolygonF polygon(boundingRect());
        QPointF p1 = polygon.last();
        QPointF p2, intersectPoint;
        QLineF line, pair(p, mapFromScene(from));
        bool haveItersect = false;

        for (int i = 0; i < polygon.size(); i++)
        {
            p2 = polygon.at(i);
            line = QLineF(p1, p2);
            QLineF::IntersectType intersectType = line.intersect(pair, &intersectPoint);
            if (intersectType == QLineF::BoundedIntersection)
            {
                haveItersect = true;
                break;
            }

            p1 = p2;
        }
        p = haveItersect ? intersectPoint : p;
    }

    return mapToScene(p);
}

void ArcItem::updateArrowPath(){
	QPainterPath path;
	if((_endItem && _startItem->primaryShape().intersects(_endItem->primaryShape())) ||
	   (!_endItem && _startItem->primaryShape().contains(_end))){
	   _cachedArrowPath = path;
		return;
	}
	QPointF start(0,0),
			point = _end - pos();

	//The arrow line and reverse liune
	QLineF revline(point, start);

	//Compute various points
	QLineF s = revline.normalVector();
	s.setAngle(revline.angle() - 45);
	s.setLength(ARROW_SIZE);
	QPointF side1 = s.p2();
	s = revline.normalVector();
	s.setAngle(revline.angle() + 45);
	s.setLength(ARROW_SIZE);
	QPointF side2 = s.p2();

	s = QLineF(side1, side2);
	QPointF head = point;
	s.intersect(revline, &head);

	path.moveTo(start);
	path.lineTo(head);
	path.lineTo(side1);
	path.lineTo(point);
	path.lineTo(side2);
	path.lineTo(head);

	_cachedArrowPath = path;
}

/**
 * @brief ... Draw vertical and horizontal axis on the frame. Marks are placed at step intervals in world reference frame
 *
 * @param c ... line color
 * @param w ... line width
 * @param step ...separation among axis marks
 * @return void
 **/
void RCDraw::drawAxis ( const QColor &c, int w, float step )
{
	drawLine ( QLineF ( effWin.left(), effWin.center().y(), effWin.right(), effWin.center().y()), w );	
	for ( float i=effWin.center().x() ; i< effWin.right(); i+=step )
	{
		drawLine ( QLineF ( i, effWin.center().y()-step, i , effWin.center().y()+step), c, w );
	}
	for ( float i=effWin.center().x() ; i> effWin.left(); i-=step )
	{
		drawLine ( QLineF ( i, effWin.center().y()-step, i , effWin.center().y()+step), c, w );
	}
	drawLine ( QLineF ( effWin.center().x(), effWin.top(), effWin.center().x(), effWin.bottom()), w );		
	for ( float i=effWin.center().y() ; i< effWin.bottom(); i+=step )
	{
		drawLine ( QLineF ( effWin.center().x()-step, i, effWin.center().x()+step, i), c, w );
	}
	for ( float i=effWin.center().y() ; i> effWin.top(); i-=step )
	{
		drawLine ( QLineF ( effWin.center().x()-step, i, effWin.center().y()+step, i), c, w );
	}
	drawText(QPointF(effWin.center().x()+1, effWin.top()), "0.5 m", effWin.width()/20, Qt::black);
}

DataWidget::DataWidget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::DataWidget)
{
    ui->setupUi(this);

    ui->graphicsView->setScene(&scene_1);
    ui->graphicsView_2->setScene(&scene_2);
    ui->graphicsView_3->setScene(&scene_3);

    QPen pen;
    pen.setColor(Qt::white);
    pen.setWidth(2);

    scene_1.addRect(QRect(0,0,185,20),pen, QBrush(Qt::NoBrush));
    scene_1.addRect(QRect(0,40,185,20),pen, QBrush(Qt::NoBrush));
    scene_1.addRect(QRect(0,80,185,20),pen, QBrush(Qt::NoBrush));

    scene_2.addRect(QRect(0,0,185,20),pen, QBrush(Qt::NoBrush));
    scene_2.addRect(QRect(0,40,185,20),pen, QBrush(Qt::NoBrush));
    scene_2.addRect(QRect(0,80,185,20),pen, QBrush(Qt::NoBrush));

    line1 = scene_1.addLine(QLineF(0.5*185,0,0.5*185,20),pen);
    line2 = scene_1.addLine(QLineF(0.5*185,40,0.5*185,60),pen);
    line3 = scene_1.addLine(QLineF(0.5*185,80,0.5*185,100),pen);

    line4 = scene_2.addLine(QLineF(0.5*185,0,0.5*185,20),pen);
    line5 = scene_2.addLine(QLineF(0.5*185,40,0.5*185,60),pen);
    line6 = scene_2.addLine(QLineF(0.5*185,80,0.5*185,100),pen);

    circle1 = scene_3.addEllipse(QRect(0,0,30,30),pen);
    circle2 = scene_3.addEllipse(QRect(0,35,30,30),pen);
    circle3 = scene_3.addEllipse(QRect(0,70,30,30),pen);

    changeLabelsColor();
    drawData();
}

QLineF bottomLine(const QmlItemNode &qmlItemNode)
{
    QRectF rectangle = qmlItemNode.instanceSceneTransform().mapRect(qmlItemNode.instanceBoundingRect()).adjusted(1, 0, 0, 0);

    return QLineF(rectangle.bottomLeft(), rectangle.bottomRight());
}

void qDrawShadePanel(QPainter *p, int x, int y, int w, int h,
                      const QPalette &pal, bool sunken,
                      int lineWidth, const QBrush *fill)
{
    if (w == 0 || h == 0)
        return;
    if (!(w > 0 && h > 0 && lineWidth >= 0)) {
        qWarning("qDrawShadePanel: Invalid parameters");
    }
    QColor shade = pal.dark().color();
    QColor light = pal.light().color();
    if (fill) {
        if (fill->color() == shade)
            shade = pal.shadow().color();
        if (fill->color() == light)
            light = pal.midlight().color();
    }
    QPen oldPen = p->pen();                        // save pen
    QVector<QLineF> lines;
    lines.reserve(2*lineWidth);

    if (sunken)
        p->setPen(shade);
    else
        p->setPen(light);
    int x1, y1, x2, y2;
    int i;
    x1 = x;
    y1 = y2 = y;
    x2 = x+w-2;
    for (i=0; i<lineWidth; i++) {                // top shadow
        lines << QLineF(x1, y1++, x2--, y2++);
    }
    x2 = x1;
    y1 = y+h-2;
    for (i=0; i<lineWidth; i++) {                // left shado
        lines << QLineF(x1++, y1, x2++, y2--);
    }
    p->drawLines(lines);
    lines.clear();
    if (sunken)
        p->setPen(light);
    else
        p->setPen(shade);
    x1 = x;
    y1 = y2 = y+h-1;
    x2 = x+w-1;
    for (i=0; i<lineWidth; i++) {                // bottom shadow
        lines << QLineF(x1++, y1--, x2, y2--);
    }
    x1 = x2;
    y1 = y;
    y2 = y+h-lineWidth-1;
    for (i=0; i<lineWidth; i++) {                // right shadow
        lines << QLineF(x1--, y1++, x2--, y2);
    }
    p->drawLines(lines);
    if (fill)                                // fill with fill color
        p->fillRect(x+lineWidth, y+lineWidth, w-lineWidth*2, h-lineWidth*2, *fill);
    p->setPen(oldPen);                        // restore pen
}

void qDrawShadeRect(QPainter *p, int x, int y, int w, int h,
                     const QPalette &pal, bool sunken,
                     int lineWidth, int midLineWidth,
                     const QBrush *fill)
{
    if (w == 0 || h == 0)
        return;
    if (! (w > 0 && h > 0 && lineWidth >= 0 && midLineWidth >= 0)) {
        qWarning("qDrawShadeRect: Invalid parameters");
        return;
    }
    QPen oldPen = p->pen();
    if (sunken)
        p->setPen(pal.dark().color());
    else
        p->setPen(pal.light().color());
    int x1=x, y1=y, x2=x+w-1, y2=y+h-1;

    if (lineWidth == 1 && midLineWidth == 0) {// standard shade rectangle
        p->drawRect(x1, y1, w-2, h-2);
        if (sunken)
            p->setPen(pal.light().color());
        else
            p->setPen(pal.dark().color());
        QLineF lines[4] = { QLineF(x1+1, y1+1, x2-2, y1+1),
                            QLineF(x1+1, y1+2, x1+1, y2-2),
                            QLineF(x1, y2, x2, y2),
                            QLineF(x2,y1, x2,y2-1) };
        p->drawLines(lines, 4);              // draw bottom/right lines
    } else {                                        // more complicated
        int m = lineWidth+midLineWidth;
        int i, j=0, k=m;
        for (i=0; i<lineWidth; i++) {                // draw top shadow
            QLineF lines[4] = { QLineF(x1+i, y2-i, x1+i, y1+i),
                                QLineF(x1+i, y1+i, x2-i, y1+i),
                                QLineF(x1+k, y2-k, x2-k, y2-k),
                                QLineF(x2-k, y2-k, x2-k, y1+k) };
            p->drawLines(lines, 4);
            k++;
        }
        p->setPen(pal.mid().color());
        j = lineWidth*2;
        for (i=0; i<midLineWidth; i++) {        // draw lines in the middle
            p->drawRect(x1+lineWidth+i, y1+lineWidth+i, w-j-1, h-j-1);
            j += 2;
        }
        if (sunken)
            p->setPen(pal.light().color());
        else
            p->setPen(pal.dark().color());
        k = m;
        for (i=0; i<lineWidth; i++) {                // draw bottom shadow
            QLineF lines[4] = { QLineF(x1+1+i, y2-i, x2-i, y2-i),
                                QLineF(x2-i, y2-i, x2-i, y1+i+1),
                                QLineF(x1+k, y2-k, x1+k, y1+k),
                                QLineF(x1+k, y1+k, x2-k, y1+k) };
            p->drawLines(lines, 4);
            k++;
        }
    }
    if (fill) {
        QBrush oldBrush = p->brush();
        int tlw = lineWidth + midLineWidth;
        p->setPen(Qt::NoPen);
        p->setBrush(*fill);
        p->drawRect(x+tlw, y+tlw, w-2*tlw, h-2*tlw);
        p->setBrush(oldBrush);
    }
    p->setPen(oldPen);                        // restore pen
}

void QcWaveform::paintEvent( QPaintEvent *ev )
{
  Q_ASSERT( pixmap != 0 );

  QPainter p( this );

  // if loading draw progress
  if( _cache && _cache->loading() ) {
    QRect r( rect() );
    p.fillRect( r, QColor(100,100,100) );
    r.setRight( r.right() * _cache->loadProgress() / 100 );
    p.fillRect( r, QColor( 0, 0, 0 ) );
    p.setPen( QColor(255,255,255) );
    QTextOption opt;
    opt.setAlignment( Qt::AlignCenter );
    p.drawText( rect(), "loading...", opt );
    return;
  }

  p.fillRect( rect(), _bkgColor );

  // draw waveform on pixmap

  if( _drawWaveform && dirty ) {
    draw( pixmap, 0, width(), _beg, _dur );
    dirty = false;
  }

  // draw selections

  p.save();

  p.scale( (double) width() / _dur, 1.0 );
  p.translate( _beg * -1.0, 0.0 );
  p.setPen( Qt::NoPen );

  int i;
  for( i = 0; i < 64; ++i ) {
    const Selection &s = _selections[i];
    if( s.size > 0 ) {
      QRectF r ( s.start, 0, s.size, height() );
      p.setBrush( s.color );
      p.drawRect( r );
    }
  }

  p.restore();

  // draw time grid

  if( _showGrid && sfInfo.samplerate > 0 && _gridResolution > 0.f ) {
    p.save();

    double durSecs = (double) _dur / sfInfo.samplerate;
    double begSecs = (double) _beg / sfInfo.samplerate;

    p.scale( width() / durSecs, 1.0 );
    p.setPen( _gridColor );

    double offset = _gridOffset - begSecs;
    offset -= ( floor( offset / _gridResolution ) * _gridResolution );
    while( offset <  durSecs ) {
      p.drawLine( QLineF( offset, 0.0, offset, height() ) );
      offset += _gridResolution;
    }

    p.restore();
  }

  // paste the waveform pixmap on screen

  if( _drawWaveform )
    p.drawPixmap( ev->rect(), *pixmap, ev->rect() );

  // draw cursor

  if( _showCursor && _cursorPos >= _beg && _cursorPos < _beg + _dur ) {
    double cursorX = (_cursorPos - _beg) / _fpp;
    p.setPen( _cursorColor );
    p.drawLine( QLineF( cursorX, 0, cursorX, height() ) );
  }
}