Esempio n. 1
0
	QPolygon ActionInstance::evaluatePolygon(bool &ok,
					   const QString &parameterName,
					   const QString &subParameterName)
	{
		if(!ok)
			return QPolygon();

		const SubParameter &subParameter = retreiveSubParameter(parameterName, subParameterName);
		QString result;

		if(subParameter.isCode())
			result = evaluateCode(ok, subParameter).toString();
		else
			result = evaluateText(ok, subParameter);

		if(!ok)
			return QPolygon();

		if(result.isEmpty() || result == QLatin1String(";"))
			return QPolygon();

		QStringList pointStrings = result.split(QLatin1Char(';'), QString::SkipEmptyParts);
		QPolygon polygon;

        for(const QString &pointString: pointStrings)
		{
			QStringList pointComponents = pointString.split(QLatin1Char(':'), QString::SkipEmptyParts);
			if(pointComponents.size() != 2)
				continue;

			polygon << QPoint(pointComponents.at(0).toInt(), pointComponents.at(1).toInt());
		}

		return polygon;
	}
void CRFTagRobot::drawPath(){

    //Flecha superior
    QVector<QPoint> arrow0;
    arrow0.append(QPoint(190, 10)); //punto sobre la recta
    arrow0.append(QPoint(200, 5));  //punto arriba de la recta
    arrow0.append(QPoint(200, 15)); //punto debajo de la recta
    //Flecha inferior
    QVector<QPoint> arrow1;
    arrow1.append(QPoint(190, 400)); //punto sobre la recta
    arrow1.append(QPoint(200, 395)); //punto arriba de la recta
    arrow1.append(QPoint(200, 405)); //punto debajo de la recta
    //Flecha diagonal 1
    QVector<QPoint> arrow2;
    arrow2.append(QPoint(170, 175)); //punto sobre de la recta
    arrow2.append(QPoint(170, 165)); //punto arriba de la recta
    arrow2.append(QPoint(160, 175)); //punto debajo de la recta
    //Flecha diagonal 2
    QVector<QPoint> arrow3;
    arrow3.append(QPoint(230, 175));
    arrow3.append(QPoint(220, 175));
    arrow3.append(QPoint(230, 185));

    this->scene.addPolygon(QPolygon(arrow0), QPen(), QBrush(QColor("black")));
    this->scene.addPolygon(QPolygon(arrow1), QPen(), QBrush(QColor("black")));
    this->scene.addPolygon(QPolygon(arrow2), QPen(), QBrush(QColor("black")));
    this->scene.addPolygon(QPolygon(arrow3), QPen(), QBrush(QColor("black")));
    this->scene.addLine(QLine(QPoint(0, 10), QPoint(400, 400)),QPen(QColor("black")));
    this->scene.addLine(QLine(QPoint(0, 400), QPoint(400, 10)),QPen(QColor("black")));
    this->scene.addLine(QLine(QPoint(0, 10), QPoint(400, 10)),QPen(QColor("black")));
    this->scene.addLine(QLine(QPoint(0, 400), QPoint(400, 400)),QPen(QColor("black")));
}
Esempio n. 3
0
void FreeRegionGrabber::mousePressEvent( QMouseEvent* e )
{
    pBefore = e->pos();
    showHelp = !helpTextRect.contains( e->pos() );
    if ( e->button() == Qt::LeftButton )
    {
        mouseDown = true;
        dragStartPoint = e->pos();
        selectionBeforeDrag = selection;
        if ( !selection.containsPoint( e->pos(), Qt::WindingFill ) )
        {
            newSelection = true;
            selection = QPolygon();
        }
        else
        {
            setCursor( Qt::ClosedHandCursor );
        }
    }
    else if ( e->button() == Qt::RightButton )
    {
        newSelection = false;
        selection = QPolygon();
        setCursor( Qt::CrossCursor );
    }
    update();
}
Esempio n. 4
0
void ICircuitView::drawImpl(const QVector<int>& inputPadding,
                            const QVector<int>& outputPadding,
                            const QString& text)
{
    const QPoint& begin = beginPoint();
    const QPoint second{begin.x() + CIRCUIT_WIDTH, begin.y()};
    const QPoint third{begin.x() + CIRCUIT_WIDTH, begin.y() + CIRCUIT_HEIGHT};
    const QPoint fourth{begin.x(), begin.y() + CIRCUIT_HEIGHT};
   
    foreach (const int padding, outputPadding)
        DrawingHelper::drawOutputWire({second.x(), second.y() + padding});
    
    foreach(const int padding, inputPadding)
        DrawingHelper::drawInputWire({begin.x(), begin.y() + padding});
    
    DrawingHelper::drawPolygon(QPolygon({begin, second, third, fourth}), Qt::white);
    DrawingHelper::drawPolygonBorder(QPolygon({begin, second, third, fourth}), Qt::black);
    
    if (m_isSelected)
        drawBorder();
    
    if (m_model != NULL)
        DrawingHelper::drawText({m_begin.x(), m_begin.y() + CIRCUIT_HEIGHT + 10},
                                "E" + QString::number(m_model->id()), m_editor);
    DrawingHelper::drawText(QPoint(begin.x() + CIRCUIT_WIDTH / 5, begin.y() + CIRCUIT_HEIGHT / 2),
                            text, editor());
}
/**********************************************************\
|****************    Private Methods   ********************|
\**********************************************************/
void IsometricCubeWidget::initIsoGrid()
{
    int sX, sY;
    QPoint isogrid[7][7];

    for (int y = 0; y < 7 ; y++)
    {
        for (int x = 0; x < 7; x++)
        {
            sX = (x * W / 2) + (y * W / 2);
            sY = (y * H / 2) - (x * H / 2);

            isogrid[x][y] = QPoint(sX,sY+H*5);
        }
    }

    for (int y = 0; y < 3 ; y++)
    {
        for (int x = 0; x < 3; x++)
        {
            // Creating the polygon's vector
            plgnUp[x][y].append(isogrid[6-y][x]);
            plgnUp[x][y].append(isogrid[6-y][x+1]);
            plgnUp[x][y].append(isogrid[5-y][x+1]);
            plgnUp[x][y].append(isogrid[5-y][x]);

            plgnFront[x][y].append(isogrid[3-y][x+y]);
            plgnFront[x][y].append(isogrid[3-y][x+y+1]);
            plgnFront[x][y].append(isogrid[2-y][x+y+2]);
            plgnFront[x][y].append(isogrid[2-y][x+y+1]);

            plgnRight[x][y].append(isogrid[3+x-y][3+y]);
            plgnRight[x][y].append(isogrid[4+x-y][3+y]);
            plgnRight[x][y].append(isogrid[3+x-y][4+y]);
            plgnRight[x][y].append(isogrid[2+x-y][4+y]);

            plgnDown[x][y].append(isogrid[x][y+4]);
            plgnDown[x][y].append(isogrid[x+1][y+4]);
            plgnDown[x][y].append(isogrid[x+1][y+3]);
            plgnDown[x][y].append(isogrid[x][y+3]);
            plgnDown[x][y].translate(4*W,0);

            plgnBack[x][y] = QPolygon(plgnRight[x][y]);
            plgnBack[x][y].translate(2.5*W,-1.5*H);

            plgnLeft[x][y] = QPolygon(plgnFront[x][y]);
            plgnLeft[x][y].translate(5.5*W,-1.5*H);
        }
    }
    shadow.append(isogrid[3][6]);
    shadow.append(isogrid[5][6]);
    shadow.append(isogrid[5][3]);
    shadow.append(isogrid[3][3]);

    frontText = QPoint(isogrid[3][0].rx() + 0.3 * W, 100);
    backText = QPoint(isogrid[4][0].rx() + 4 * W, 100);
}
Esempio n. 6
0
  void maskRenderWidget::mousePressEvent(QMouseEvent *e)
  {
    if (e->button() == Qt::LeftButton)
    {
      if (e->modifiers() & Qt::ShiftModifier)
      {
				emit pointSelected(e->pos());
      }
      else
      {
				pimpl_->undo_.push(pimpl_->foreground_);
				pimpl_->end_point_ = e->pos();
				pimpl_->polygon_ = QPolygon();
				pimpl_->polygon_ << e->pos();
				priv::unwind(pimpl_->redo_);
				pimpl_->shape_ = Impl::Point;
				update();
      }
    }
    else if (e->button() == Qt::RightButton)
    {
      pimpl_->undo_.push(pimpl_->foreground_);
      QApplication::setOverrideCursor(QCursor(Qt::CrossCursor));
      pimpl_->start_point_ = e->pos();
      pimpl_->shape_ = Impl::Rubber;
    }
  }
Esempio n. 7
0
void FlowContainer::setFullBounds( bool full )
{
	if ( full || !b_expanded )
	{
		QRect bounds = b_expanded ? m_sizeRect : QRect( m_sizeRect.x(), m_sizeRect.y(), m_sizeRect.width(), topStrip );
		setPoints( QPolygon(bounds) );
		return;
	}
	
// 	kDebug() << k_funcinfo << "width="<<width()<<" height="<<height()<<endl;
	
	QPolygon pa(10);
	pa[0] = QPoint( 0, 0 );
	pa[1] = QPoint( width(), 0 );
	pa[2] = QPoint( width(), height() );
	pa[3] = QPoint( 0, height() );
	pa[4] = QPoint( 0, 0 );
	pa[5] = QPoint( 8, topStrip );
	pa[6] = QPoint( 8, height()-botStrip );
	pa[7] = QPoint( width()-8, height()-botStrip );
	pa[8] = QPoint( width()-8, topStrip );
	pa[9] = QPoint( 8, topStrip );
	pa.translate( offsetX(), offsetY() );
	setPoints(pa);
}
Esempio n. 8
0
/*! @brief  only draw the shape in the image*/
void
Dialog::paint(QImage & img)
{
   QPainter painter(&img);
   painter.setPen(QPen(Qt::red,1,Qt::SolidLine));
   if(is_draw_Img_[Img_selected_])
   {
      if(Img_selected_!=0)
         painter.drawPolygon(QPolygon(poly_pts_));
      else
      {
          if(is_draw_big_circle_)
          {
             circle_center_=(circle_diameter_[0]+circle_diameter_[1])/2;
             QPoint vect=circle_diameter_[0]-circle_diameter_[1];
             circle_radius_=(int)std::sqrt(vect.x()*vect.x()+vect.y()*vect.y())/2.0;
             painter.drawEllipse(circle_center_,circle_radius_,circle_radius_);
          }
          if(is_draw_small_circle_)
          {
             QPoint vect=circle_center_-small_edge_;
             small_radius_=(int)std::sqrt(vect.x()*vect.x()+vect.y()*vect.y());
             painter.drawEllipse(circle_center_,small_radius_,small_radius_);
          }
      }
   }
   update();
}
Esempio n. 9
0
QPolygon StyleHelper::bubbleFromSize(const QSize& sz, int nAngle, bool bAlignLeft)
{
    Q_ASSERT(sz.width() > 31);
    Q_ASSERT(sz.height() > 11);

    QVector<QPoint> ps;
    if (bAlignLeft) {
        ps.push_back(QPoint(0, nAngle));
        ps.push_back(QPoint(11, nAngle));
        ps.push_back(QPoint(11 + nAngle, 0));
        ps.push_back(QPoint(11 + nAngle * 2, nAngle));
        ps.push_back(QPoint(sz.width(), nAngle));
        ps.push_back(QPoint(sz.width(), sz.height()));
        ps.push_back(QPoint(0, sz.height()));
    } else {
        ps.push_back(QPoint(1, 10));
        ps.push_back(QPoint(sz.width() - 11 - nAngle * 2, nAngle));
        ps.push_back(QPoint(sz.width() - 11 - nAngle, 0));
        ps.push_back(QPoint(sz.width() - 11, nAngle));
        ps.push_back(QPoint(sz.width() - 1, nAngle));
        ps.push_back(QPoint(sz.width(), nAngle + 1));
        ps.push_back(QPoint(sz.width(), sz.height()));
        ps.push_back(QPoint(0, sz.height()));
        ps.push_back(QPoint(0, nAngle + 1));
    }

    return QPolygon(ps);
}
Esempio n. 10
0
QPolygon WorldPainter::getTriangle() {
	return QPolygon(QVector<QPoint> {
		QPoint(-1, -1),
		QPoint(-1,  1),
		QPoint( 1,  0)
	});
}
Esempio n. 11
0
/**
 * @brief Recalculate our positions to track the anchor
 */
void CallConfirmWidget::reposition()
{
    if (parentWidget())
        parentWidget()->removeEventFilter(this);

    setParent(anchor->window());
    parentWidget()->installEventFilter(this);

    QWidget* w = anchor->window();
    QPoint pos = anchor->mapToGlobal({(anchor->width()-rectW)/2,anchor->height()})-w->mapToGlobal({0,0});

    // We don't want the widget to overflow past the right of the screen
    int xOverflow=0;
    if (pos.x() + rectW > w->width())
        xOverflow = pos.x() + rectW - w->width();
    pos.rx() -= xOverflow;

    mainRect = {0,spikeH,rectW,rectH};
    brush = QBrush(QColor(65,65,65));
    spikePoly = QPolygon({{(rectW-spikeW)/2+xOverflow,spikeH},
                          {rectW/2+xOverflow,0},
                          {(rectW+spikeW)/2+xOverflow,spikeH}});

    move(pos);
    update();
}
Esempio n. 12
0
	void LineString::draw(QPainter* painter, const MapAdapter* mapadapter, const QRect &screensize, const QPoint offset)
	{
		if (!visible)
			return;
	
		QPolygon p = QPolygon();
	
		QPointF c;
		for (int i=0; i<vertices.size(); i++)
		{
			c = vertices[i]->coordinate();
			p.append(mapadapter->coordinateToDisplay(c));
		}
		if (mypen != 0)
		{
			painter->save();
			painter->setPen(*mypen);
		}
		painter->drawPolyline(p);
		if (mypen != 0)
		{
			painter->restore();
		}
		for (int i=0; i<vertices.size(); i++)
		{
			vertices[i]->draw(painter, mapadapter, screensize, offset);
		}
	}
QPointF KisCoordinatesConverter::imageCenterInWidgetPixel() const
{
    if(!m_d->image)
        return QPointF();
    
    QPolygonF poly = imageToWidget(QPolygon(m_d->image->bounds()));
    return (poly[0] + poly[1] + poly[2] + poly[3]) / 4.0;
}
Esempio n. 14
0
void DeviceSkin::setView( QWidget *v )
{
    m_view = v;
    m_view->setFocus();
    m_view->move(transform.map(QPolygon(m_parameters.screenRect)).boundingRect().topLeft());
    if ( cursorw )
	cursorw->setView(v);
}
Esempio n. 15
0
/*!
    Returns the Bezier points for the four control points in this
    array.
*/
Q3PointArray Q3PointArray::cubicBezier() const
{
    if (size() != 4) {
	qWarning( "Q3PointArray::bezier: The array must have 4 control points" );
        return QPolygon();
    }
    QPolygonF polygon = QBezier::fromPoints(at(0), at(1), at(2), at(3)).toPolygon();
    return polygon.toPolygon();
}
Esempio n. 16
0
void DeviceSkin::updateSecondaryScreen()
{
    if (!m_secondaryView)
        return;
    if (flipped_open) {
        if (m_parameters.backScreenRect.isNull()) {
            m_secondaryView->hide();
        } else {
            m_secondaryView->move(transform.map(QPolygon(m_parameters.backScreenRect)).boundingRect().topLeft());
            m_secondaryView->show();
        }
    } else {
        if (m_parameters.closedScreenRect.isNull()) {
            m_secondaryView->hide();
        } else {
            m_secondaryView->move(transform.map(QPolygon(m_parameters.closedScreenRect)).boundingRect().topLeft());
            m_secondaryView->show();
        }
    }
}
Esempio n. 17
0
void QStyleRangeSlider::paintGroove(QPainter& p, const QRect& bbox) const
{
  QRect paintBox;

  paintBox.setX(getGrooveX(bbox));
  paintBox.setY(getGrooveY(bbox));
  paintBox.setWidth(getGrooveWidth(bbox));
  paintBox.setHeight(getGrooveHeight(bbox));


  QPolygonF paintArea = QPolygon(paintBox, true);

  float offset = 0.025;
  float aspect =
    getGrooveWidth(bbox) * 1.0 /
    getGrooveHeight(bbox);

  offset = 0.2;
  float offset2 = offset / aspect;

  for (int i = 4; i > 0; --i) {
    if(i % 2 == 0) {
      point_insert(paintArea, i, offset);
      point_insert(paintArea, i-1, 1 - offset2);
    }
    else {
      point_insert(paintArea, i, offset2);
      point_insert(paintArea, i - 1, 1 - offset);
    }
    cubic_subdivide(paintArea, i, 7);
  }

  QRectF pbbox = paintArea.boundingRect();

  QPointF p1 = pbbox.topLeft();
  QPointF p2 = pbbox.bottomRight();
  p2.setX(p1.x());

  QLinearGradient grad(p1, p2);
  grad.setColorAt(0, Qt::black);
  grad.setColorAt(0.15, Qt::gray);
  grad.setColorAt(0.85, Qt::gray);
  grad.setColorAt(1.0, Qt::white);

  //p.fillRect(bbox, Qt::blue);
  p.save();
  //p.setRenderHint(QPainter::Antialiasing, true);
  p.setRenderHint(QPainter::HighQualityAntialiasing, true);
  p.setPen(Qt::NoPen);
  //p.drawPoints(paintArea);
  p.setBrush(QBrush(grad));
  p.drawPolygon(paintArea);
  p.restore();
}
Esempio n. 18
0
void DeviceSkin::setTransform( const QMatrix& wm )
{
    transform = QImage::trueMatrix(wm,m_parameters.skinImageUp.width(),m_parameters.skinImageUp.height());
    calcRegions();
    loadImages();
    if ( m_view ) {
        QPoint p = transform.map(QPolygon(m_parameters.screenRect)).boundingRect().topLeft();
	m_view->move(p);
    }
    updateSecondaryScreen();
}
Esempio n. 19
0
/*
* MarkTriangle
*/
MarkTriangle::MarkTriangle(int x, int y, double s, QGraphicsScene *canvas, QColor col)
: QGraphicsPolygonItem(0, canvas), Mark(x, y)
{
	if (setting->readBoolEntry("BOLD_MARKS"))
		setPen(QPen(col, 2));
	else
		setPen(QPen(col, 1));
	pa = QPolygon(3);
	setSize(s, s);
	setZValue(10);
}
Esempio n. 20
0
void Fate::paintEvent(QPaintEvent *e)
{
        QPainter painter(this);
        QPen pen(Qt::black, 2, Qt::SolidLine);
        painter.setPen(pen);

        painter.fillRect(*borders, QColor(0, 90, 0));

        painter.setBrush(QColor(200,0,0));
        painter.drawPolygon(QPolygon(dangerZone.getPositions()));
        spidey->draw(&painter);
}
Esempio n. 21
0
void tst_QRegion::emptyPolygonRegion_data()
{
    QTest::addColumn<QPolygon>("pa");
    QTest::addColumn<bool>("isEmpty");
    QTest::addColumn<int>("numRects");
    QTest::addColumn<QVector<QRect> >("rects");

    QPolygon pa;


    QTest::newRow("no points") << pa << true << 0 << QVector<QRect>();
    pa = QPolygon() << QPoint(10,10);
    QTest::newRow("one point") << pa << true << 0 << QVector<QRect>();
    pa = QPolygon() << QPoint(10,10) << QPoint(10,20);
    QTest::newRow("two points, horizontal") << pa << true << 0 << QVector<QRect>();

    pa = QPolygon() << QPoint(10,10) << QPoint(20,10);
    QTest::newRow("two points, vertical") << pa << true << 0 << QVector<QRect>();

    pa = QPolygon() << QPoint(10,10) << QPoint(20,20);
    QTest::newRow("two points, diagonal") << pa << true << 0 << QVector<QRect>();

    pa = QPolygon() << QPoint(10,10) << QPoint(15,15) << QPoint(10,15) << QPoint(10, 10) ;
    QVector<QRect> v;
    v << QRect(10,11,1, 1) << QRect(10,12,2,1) << QRect(10,13,3,1) << QRect(10,14,4,1);
    QTest::newRow("triangle") << pa << false << 4 << v;

    v.clear();
    v << QRect(10,10,10,10);

    QTest::newRow("rectangle") << QPolygon(QRect(10,10,10,10))  << false << 1 << v;

}
Esempio n. 22
0
QPixmap RoutingInputWidgetPrivate::addDropDownIndicator(const QPixmap &pixmap)
{
    QPixmap result( pixmap.size() + QSize( 8, pixmap.height() ) );
    result.fill( QColor( Qt::transparent ) );
    QPainter painter( &result );
    painter.drawPixmap( 0, 0, pixmap );
    QPoint const one( pixmap.width() + 1, pixmap.height() - 8 );
    QPoint const two( one.x() + 6, one.y() );
    QPoint const three( one.x() + 3, one.y() + 4 );
    painter.setRenderHint( QPainter::Antialiasing, true );
    painter.setPen( Qt::NoPen );
    painter.setBrush( QColor( Oxygen::aluminumGray4 ) );
    painter.drawConvexPolygon( QPolygon() << one << two << three );
    return result;
}
/*void MapVectors::mouseMoveEvent(QMouseEvent *event)
{

}
void MapVectors::mousePressEvent(QMouseEvent *event)
{
    this->mapPoints->push_back(QPoint(event->x(),event->y()));
    update();
}

void MapVectors::mouseReleaseEvent(QMouseEvent *event)
{

}
*/
void MapVectors::paintEvent(QPaintEvent *event)

{

    QPainter painter(this);
   // painter.drawImage(QRect(0,-yoffset,1000,600+yoffset),mapPic,QRect(0,0,4200,2500));
    painter.setPen(col.darker());
    painter.setBrush(col.lighter());
    for(int i=0;i<mapPoints->count()-1;i++)
    {
        painter.drawLine(mapPoints->at(i),mapPoints->at(i+1));
        //painter.drawEllipse(mapPoints->at(i+1),5,5);
        painter.drawPolygon(QPolygon(*mapPoints));

    }
}
Esempio n. 24
0
void tst_QPolygon::boundingRect_data()
{
    QTest::addColumn<QPolygon>("poly");
    QTest::addColumn<QRect>("brect");

#define ROW(args, rect) \
    do { \
        QPolygon poly; \
        poly.setPoints args; \
        QTest::newRow(#args) << poly << QRect rect; \
    } while (0)

    QTest::newRow("empty") << QPolygon() << QRect(0, 0, 0, 0);
    ROW((1,  0,1),             ( 0, 1, 1, 1));
    ROW((2,  0,1,  1,0),       ( 0, 0, 2, 2));
    ROW((3, -1,1, -1,-1, 1,0), (-1,-1, 3, 3));
#undef ROW
}
Esempio n. 25
0
bool Storage::confirmSelection()
{
    if (BoundingBoxTool == tool_) {
        Rect *_bbox = new Rect;
        rect.setCoordinates(rect.getCoordinates().normalized());
        *_bbox = rect;
        _rect_list->append(*_bbox);
        rect.setCoordinates(QRect(-1, -1, 0, 0));
        state_ = StandBy;
        update();
        return true;

    }
    else if (PolygonTool == tool_) {
        Polygon *_pol = new Polygon;
        *_pol = poly;
        _polygon_list->append(*_pol);
        poly.setCoordinates(QPolygon());
        state_ = StandBy;
        update();
        return true;
    }
    else if (EllipseTool == tool_) {
        Ellipse *_ell = new Ellipse;
        ell.setCoordinates(ell.getCoordinates().normalized());
        *_ell = ell;
        _ellipse_list->append(*_ell);
        ell.setCoordinates(QRect(-1, -1, 0, 0));
        state_ = StandBy;
        update();
        return true;
    }
    else if (ArrowTool == tool_) {
        Arrow *_arrow = new Arrow;
        *_arrow = arrow;
        _arrow_list->append(*_arrow);
        arrow.setCoordinates(QLineF(-1, -1, -2, -2));
        state_ = StandBy;
        update();
        return true;
    }
    return false;
}
Esempio n. 26
0
//==============================================================
//  Чтение QPolygon из XML
//==============================================================
QPolygon readPolygonFromXml(QDomElement root, bool *ok)
{
    Q_ASSERT(!root.isNull());
    Q_ASSERT(ok != nullptr);

    QDomElement elemPoint = root.firstChildElement("Point");
    QVector<QPoint> points;
    while (elemPoint.isNull())
    {
        const QPoint pt = readPointFromXml(elemPoint, ok);
        if (!*ok)
            return QPolygon {};

        points << pt;

        elemPoint = root.nextSiblingElement("Point");
    }

    return QPolygon(points);
}
Esempio n. 27
0
void Item::setSize( QRect sizeRect, bool forceItemPoints )
{
	if ( !canvas() )
		return;
	
	if ( m_sizeRect == sizeRect && !forceItemPoints )
		return;
	
	if ( !preResize(sizeRect) )
		return;
	
	canvas()->setChanged(areaPoints().boundingRect());
	m_sizeRect = sizeRect;
	if ( m_itemPoints.isEmpty() || forceItemPoints )
	{
		setItemPoints( QPolygon( m_sizeRect ), false );
	}
	canvas()->setChanged(areaPoints().boundingRect());
	postResize();
	emit resized();
}
Esempio n. 28
0
void
QStyleRangeSlider::paintFilling(QPainter& p, const QRect& bbox,
                                const QPair<int, int>& range,
                                const QPair<int, int>& cutoffRange) const
{

  QRect paintBox;

  int x = getPosMin(bbox, range.first, cutoffRange);
  int width = getPosMax(bbox, range.second, cutoffRange) - x;

  paintBox.setX(x);
  paintBox.setY(getGrooveY(bbox));
  paintBox.setWidth(width);
  paintBox.setHeight(getGrooveHeight(bbox));

  QPolygon paintArea = QPolygon(paintBox, true);

  QRectF pbbox = paintArea.boundingRect();

  QPointF p1 = pbbox.topLeft();
  QPointF p2 = pbbox.bottomRight();
  p2.setX(p1.x());

  QLinearGradient grad(p1, p2);
  grad.setColorAt(0, Qt::black);
  grad.setColorAt(0.15, Qt::red);
  grad.setColorAt(0.85, Qt::red);
  grad.setColorAt(1.0, Qt::white);

  p.save();
  //p.setRenderHint(QPainter::Antialiasing, true);
  p.setRenderHint(QPainter::HighQualityAntialiasing, true);
  p.setPen(Qt::NoPen);
  //p.drawPoints(paintArea);
  p.setBrush(QBrush(grad));
  p.drawPolygon(paintArea);
  p.restore();

}
Esempio n. 29
0
void QgsMapOverviewCanvas::drawExtentRect()
{
  if ( !mMapCanvas ) return;

  const QgsRectangle &extent = mMapCanvas->extent();

  // show only when valid extent is set
  if ( extent.isEmpty() || mSettings.visibleExtent().isEmpty() )
  {
    mPanningWidget->hide();
    return;
  }

  const QPolygonF &vPoly = mMapCanvas->mapSettings().visiblePolygon();
  const QgsMapToPixel &cXf = mSettings.mapToPixel();
  QVector< QPoint > pts;
  pts.push_back( cXf.transform( QgsPointXY( vPoly[0] ) ).toQPointF().toPoint() );
  pts.push_back( cXf.transform( QgsPointXY( vPoly[1] ) ).toQPointF().toPoint() );
  pts.push_back( cXf.transform( QgsPointXY( vPoly[2] ) ).toQPointF().toPoint() );
  pts.push_back( cXf.transform( QgsPointXY( vPoly[3] ) ).toQPointF().toPoint() );
  mPanningWidget->setPolygon( QPolygon( pts ) );
  mPanningWidget->show(); // show if hidden
}
Esempio n. 30
0
//  ////////////////////////////Drawing the inactive intersection space////////////////////////////////////
void LvlScene::drawSpace()
{
    const long padding = 400000;

    WriteToLog(QtDebugMsg, QString("Draw intersection space-> Find and remove current"));
    foreach(QGraphicsItem * spaceItem, items())
    {
        if(spaceItem->data(0).toString()=="Space")
        {
            removeItem(spaceItem);
            delete spaceItem;
            continue;
        }
        if(spaceItem->data(0).toString()=="SectionBorder")
        {
            removeItem(spaceItem);
            delete spaceItem;
            continue;
        }
    }

    QPolygon bigSpace;
    QGraphicsItem * item;
    QGraphicsItem * item2;
    QVector<QPoint > drawing;

    int i, j;
    long l, r, t, b;
    //x, y, h, w;

    WriteToLog(QtDebugMsg, QString("Draw intersection space-> Find minimal"));
    j=-1;
    do
    {
        j++;
        l = LvlData->sections[j].size_left;
        r = LvlData->sections[j].size_right;
        t = LvlData->sections[j].size_top;
        b = LvlData->sections[j].size_bottom;
    }
    while(
        ((LvlData->sections[j].size_left==0) &&
         (LvlData->sections[j].size_right==0) &&
         (LvlData->sections[j].size_top==0) &&
         (LvlData->sections[j].size_bottom==0)) && (j<LvlData->sections.size())
    );

    for(i=0; i<LvlData->sections.size(); i++)
    {

        if(
            (LvlData->sections[i].size_left==0) &&
            (LvlData->sections[i].size_right==0) &&
            (LvlData->sections[i].size_top==0) &&
            (LvlData->sections[i].size_bottom==0))
            continue;

        if(LvlData->sections[i].size_left < l)
            l = LvlData->sections[i].size_left;
        if(LvlData->sections[i].size_right > r)
            r = LvlData->sections[i].size_right;
        if(LvlData->sections[i].size_top < t)
            t = LvlData->sections[i].size_top;
        if(LvlData->sections[i].size_bottom > b)
            b = LvlData->sections[i].size_bottom;
    }

    WriteToLog(QtDebugMsg, QString("Draw intersection space-> Draw polygon"));

    drawing.clear();
    drawing.push_back(QPoint(l-padding, t-padding));
    drawing.push_back(QPoint(r+padding, t-padding));
    drawing.push_back(QPoint(r+padding, b+padding));
    drawing.push_back(QPoint(l-padding, b+padding));
    drawing.push_back(QPoint(l-padding, t+padding));

    bigSpace = QPolygon(drawing);


    l = LvlData->sections[LvlData->CurSection].size_left;
    r = LvlData->sections[LvlData->CurSection].size_right;
    t = LvlData->sections[LvlData->CurSection].size_top;
    b = LvlData->sections[LvlData->CurSection].size_bottom;


    WriteToLog(QtDebugMsg, QString("Draw intersection space-> Draw editing hole"));
    drawing.clear();
    drawing.push_back(QPoint(l-1, t-1));
    drawing.push_back(QPoint(r+1, t-1));
    drawing.push_back(QPoint(r+1, b+1));
    drawing.push_back(QPoint(l-1, b+1));
    drawing.push_back(QPoint(l-1, t-1));

    bigSpace = bigSpace.subtracted(QPolygon(drawing));

    WriteToLog(QtDebugMsg, QString("Draw intersection space-> add polygon to Item"));
    item = addPolygon(bigSpace, QPen(Qt::NoPen), QBrush(Qt::black));//Add inactive space
    item2 = addPolygon(QPolygon(drawing), QPen(Qt::red, 2));
    item->setZValue(spaceZ1);
    item2->setZValue(spaceZ2);
    item->setOpacity(qreal(0.4));
    item->setData(0, "Space");
    item2->setData(0, "SectionBorder");

}