void FreeRegionGrabber::grabRect() { QPolygon pol = selection; if ( !pol.isEmpty() ) { grabbing = true; int xOffset = pixmap.rect().x() - pol.boundingRect().x(); int yOffset = pixmap.rect().y() - pol.boundingRect().y(); QPolygon translatedPol = pol.translated(xOffset, yOffset); QPixmap pixmap2(pol.boundingRect().size()); pixmap2.fill(Qt::transparent); QPainter pt; pt.begin(&pixmap2); if (pt.paintEngine()->hasFeature(QPaintEngine::PorterDuff)) { pt.setRenderHints(QPainter::Antialiasing | QPainter::HighQualityAntialiasing | QPainter::SmoothPixmapTransform, true); pt.setBrush(Qt::black); pt.setPen(QPen(QBrush(Qt::black), 0.5)); pt.drawPolygon(translatedPol); pt.setCompositionMode(QPainter::CompositionMode_SourceIn); } else { pt.setClipRegion(QRegion(translatedPol)); pt.setCompositionMode(QPainter::CompositionMode_Source); } pt.drawPixmap(pixmap2.rect(), pixmap, pol.boundingRect()); pt.end(); emit freeRegionUpdated(pol); emit freeRegionGrabbed(pixmap2); } }
void paintEvent( QPaintEvent* pe ) override { Q_UNUSED( pe ); QPainter p; p.begin( this ); p.setPen( Qt::red ); QPolygonF t = mPoly.translated( -mPoly.boundingRect().left(), -mPoly.boundingRect().top() ); p.drawConvexPolygon( t ); p.end(); }
QSize KDChart::TextLayoutItem::calcSizeHint( QFont fnt, QPoint& topLeftPt, QPoint& topRightPt, QPoint& bottomRightPt, QPoint& bottomLeftPt ) const { const QSize siz( unrotatedSizeHint( fnt )); //qDebug() << "-------- siz: "<<siz; if( ! mAttributes.rotation() ){ topLeftPt = QPoint(0,0); topRightPt = QPoint(siz.width(),0); bottomRightPt = QPoint(siz.width(),siz.height()); bottomLeftPt = QPoint(0,siz.height()); return siz; } const QRect rect(QPoint(0, 0), siz + QSize(4,4)); const qreal angle = PI * mAttributes.rotation() / 180.0; const qreal cosAngle = cos( angle ); const qreal sinAngle = sin( angle ); QMatrix rotationMatrix(cosAngle, sinAngle, -sinAngle, cosAngle, 0, 0); QPolygon rotPts; rotPts << rotationMatrix.map(rect.topLeft()) << rotationMatrix.map(rect.topRight()) << rotationMatrix.map(rect.bottomRight()) << rotationMatrix.map(rect.bottomLeft()); QSize rotSiz( rotPts.boundingRect().size() ); //qDebug() << "-------- KDChart::TextLayoutItem::calcSizeHint() returns:"<<rotSiz<<rotPts; topLeftPt = rotPts[0]; topRightPt = rotPts[1]; bottomRightPt = rotPts[2]; bottomLeftPt = rotPts[3]; return rotSiz; }
QRectF rotatedRect( const QRectF& oldRect, qreal angleInt, const QPointF& center ) { const QRect rect( oldRect.translated( center ).toRect() ); const qreal angle = PI * angleInt / 180.0; const qreal cosAngle = cos( angle ); const qreal sinAngle = sin( angle ); QMatrix rotationMatrix(cosAngle, sinAngle, -sinAngle, cosAngle, 0, 0); QPolygon rotPts; rotPts << rotationMatrix.map(rect.topLeft()) //QPoint(0,0) << rotationMatrix.map(rect.topRight()) << rotationMatrix.map(rect.bottomRight()) << rotationMatrix.map(rect.bottomLeft()); //<< rotatedPoint(rect.topRight(), angleInt, center).toPoint() //<< rotatedPoint(rect.bottomRight(), angleInt, center).toPoint() //<< rotatedPoint(rect.bottomLeft(), angleInt, center).toPoint(); return rotPts.boundingRect(); /* const QPointF topLeft( rotatedPoint( oldRect.topLeft(), angle, center ) ); const QPointF topRight( rotatedPoint( oldRect.topRight(), angle, center ) ); const QPointF bottomLeft( rotatedPoint( oldRect.bottomLeft(), angle, center ) ); const QPointF bottomRight( rotatedPoint( oldRect.bottomRight(), angle, center ) ); const qreal x = qMin( qMin( topLeft.x(), topRight.x() ), qMin( bottomLeft.x(), topLeft.x() ) ); const qreal y = qMin( qMin( topLeft.y(), topRight.y() ), qMin( bottomLeft.y(), topLeft.y() ) ); const qreal width = qMax( qMax( topLeft.x(), topRight.x() ), qMax( bottomLeft.x(), topLeft.x() ) ) - x; const qreal height = qMax( qMax( topLeft.y(), topRight.y() ), qMax( bottomLeft.y(), topLeft.y() ) ) - y; return QRectF( x, y, width, height ); */ }
void QgsPanningWidget::setPolygon( const QPolygon& p ) { if ( p == mPoly ) return; mPoly = p; setGeometry( p.boundingRect() ); update(); }
QPolygon sdraw::normalizePolygon(const QPolygon &polygon, int offset) { QPolygon ret = polygon; QRect boundingRect = ret.boundingRect(); QPoint transPt(-boundingRect.topLeft().x() + offset, -boundingRect.topLeft().y() + offset); ret.translate(transPt); return ret; }
QVariant PdfFrameHandle::itemChange (GraphicsItemChange change, const QVariant &value) { QVariant valueFiltered = value; if (change == ItemPositionChange && scene()) { QPointF sizeAsPointF (boundingRect().size().width(), boundingRect().size().height()); // New position is in the value argument QPointF newPos = valueFiltered.toPointF(); QPointF oldPos = pos (); // This sequence is from http://www.qtcentre.org/threads/47248-How-to-efficiently-get-position-of-a-QGraphicsItem-in-view-coordinates QRectF newRectItem (newPos, QSize (boundingRect().size().width(), boundingRect().size().height())); QPolygonF newRectScene = mapToScene (newRectItem); QPolygon newRectView = m_view.mapFromScene (newRectScene.boundingRect()); // Skip moving of this handle if it will go outside of the window QRectF rectWindow = m_scene.sceneRect(); if (!rectWindow.contains (newRectView.boundingRect())) { // Keep the item inside the scene rectangle newPos.setX (qMin (rectWindow.right(), qMax (newPos.x(), rectWindow.left()))); newPos.setY (qMin (rectWindow.bottom(), qMax (newPos.y(), rectWindow.top()))); valueFiltered = (newPos); } // Skip moving of other handles, in response to the move of this handle, if event handling is (temporarily) off, // to prevent an infinite loop if (!m_disableEventsWhileMovingAutomatically) { bool left = ((m_orientationFlags & PdfCropping::PDF_CROPPING_LEFT ) != 0); bool right = ((m_orientationFlags & PdfCropping::PDF_CROPPING_RIGHT ) != 0); bool top = ((m_orientationFlags & PdfCropping::PDF_CROPPING_TOP ) != 0); bool bottom = ((m_orientationFlags & PdfCropping::PDF_CROPPING_BOTTOM) != 0); if (left && top) { m_pdfCropping.moveTL (newPos, oldPos); } else if (right && top) { m_pdfCropping.moveTR (newPos, oldPos); } else if (right && bottom) { m_pdfCropping.moveBR (newPos, oldPos); } else if (left && bottom) { m_pdfCropping.moveBL (newPos, oldPos); } } } return QGraphicsItem::itemChange(change, valueFiltered); }
/** Save a QPolygon to a stream in a shorter form. */ void ShortSave(QDataStream & s, const QPolygon& a) { //first, check if we _can_ do this the short way... QRect bBox = a.boundingRect(); if (bBox.width() <= 254 && bBox.height() <= 254) { //qDebug("using 8 bits format"); //ok, we can do our own saving in 8 bits format to save space s << (qint8) 1; //set flag to say we used this format :-) QPoint topLeft = bBox.topLeft(); //get the coordinates of the top left of the box s << topLeft; QPolygon ca(a); ca.translate(-topLeft.x(), -topLeft.y()); // translate the box so it's top left on (0,0) //now, all points in the array fit into 16 bits! s << (quint32) ca.count(); for (int i = 0; i < ca.count(); i++) { s << (quint8) ca.at(i).x(); s << (quint8) ca.at(i).y(); } } else if (bBox.width() < 65500 && bBox.height() < 65500) { //qDebug("using 16 bits format"); //ok, we can do our own saving in 16 bits format to save space s << (qint8) 2; //set flag to say we used this format :-) QPoint topLeft = bBox.topLeft(); //get the coordinates of the top left of the box s << topLeft; QPolygon ca(a); ca.translate(-topLeft.x(), -topLeft.y()); // translate the box so it's top left on (0,0) //now, all points in the array fit into 32 bits! s << (quint32) ca.count(); for (int i = 0; i < ca.count(); i++) { s << (quint16) ca.at(i).x(); s << (quint16) ca.at(i).y(); } } else { //qDebug("using long 32 bits format."); //too big. We need to use the normal 2x32 bits format :-( s << (qint8) 4; //we need to set a flag that we use the normal format s << a; } }
//! Sutherland-Hodgman polygon clipping QPolygon GraphPolygonClipper::clipPolygon(const QPolygon &pa) const { if ( contains( pa.boundingRect() ) ) return pa; QPolygon cpa(pa.size()); clipEdge((Edge)0, pa, cpa); for ( uint edge = 1; edge < NEdges; edge++ ) { const QPolygon rpa = cpa; clipEdge((Edge)edge, rpa, cpa); } return cpa; }
LineElement::LineElement( const QString& name, const BaseMapElement::objectType t, const QPolygon& pP, const bool isV, const unsigned short secID, const QString& country ) : BaseMapElement(name, t, secID, country), projPolygon(pP), bBox(pP.boundingRect()), valley(isV), closed(false) { if( typeID == BaseMapElement::Lake || typeID == BaseMapElement::City || typeID == BaseMapElement::Forest ) { closed = true; } }
void QGVPage::drawBackground(QPainter *p, const QRectF &) { //Note: Background is not part of scene() if(!drawBkg) return; if (!m_vpPage->getDrawPage()) { //Base::Console().Log("TROUBLE - QGVP::drawBackground - no Page Object!\n"); return; } p->save(); p->resetTransform(); p->setBrush(*bkgBrush); p->drawRect(viewport()->rect().adjusted(-2,-2,2,2)); //just bigger than viewport to prevent artifacts if(!m_vpPage) { return; } // Default to A3 landscape, though this is currently relevant // only for opening corrupt docs, etc. float pageWidth = 420, pageHeight = 297; if ( m_vpPage->getDrawPage()->hasValidTemplate() ) { pageWidth = Rez::guiX(m_vpPage->getDrawPage()->getPageWidth()); pageHeight = Rez::guiX(m_vpPage->getDrawPage()->getPageHeight()); } // Draw the white page QRectF paperRect(0, -pageHeight, pageWidth, pageHeight); QPolygon poly = mapFromScene(paperRect); QBrush pageBrush(Qt::white); p->setBrush(pageBrush); p->drawRect(poly.boundingRect()); p->restore(); }
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(); }
void SaxsviewMask::Private::setValue(SaxsviewMask *mask, const QPolygonF& p, double value) { if (SaxsviewFrameData *d = (SaxsviewFrameData*)(mask->data())) { // QPolygonF::toPolygon() internally uses toPoint() rounding, see above. QPolygon polygon; foreach (QPointF pt, p) polygon << QPoint((int)pt.x(), (int)pt.y()); const QRect r = polygon.boundingRect(); if (polygon.size() > 2) { for (int x = r.x(); x <= r.x() + r.width(); ++x) for (int y = r.y(); y <= r.y() + r.height(); ++y) if (polygon.containsPoint(QPoint(x, y), Qt::OddEvenFill)) d->setValue(x, y, value); } else bresenham(polygon[0].x(), polygon[0].y(), polygon[1].x(), polygon[1].y(), d, value); modified = true; mask->plot()->replot(); } }
/* * This implementation is from QWindowsStyle (Qt 7.2) * * It is licensed under the GPL 3: * Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). * Contact: Nokia Corporation ([email protected]) */ void StyleHelper::drawArrow( QStyle::PrimitiveElement element, QPainter* p, const QStyleOption* opt ) { if ( opt->rect.width() <= 1 || opt->rect.height() <= 1 ) return; QRect r = opt->rect; int size = qMin( r.height(), r.width() ); QPixmap pixmap; QString pixmapName; pixmapName.sprintf( "arrow-%s-%d-%d-%d-%lld", "$qt_ia", uint(opt->state), element, size, opt->palette.cacheKey() ); if ( !QPixmapCache::find( pixmapName, pixmap) ) { int border = size / 5; int sqsize = 2 * ( size / 2 ); QImage image( sqsize, sqsize, QImage::Format_ARGB32 ); image.fill( 0 ); QPainter imagePainter( &image ); imagePainter.setRenderHint( QPainter::Antialiasing, true ); QPolygon a; switch ( element ) { case QStyle::PE_IndicatorArrowUp: a.setPoints( 3, border, sqsize / 2, sqsize / 2, border, sqsize - border, sqsize / 2 ); break; case QStyle::PE_IndicatorArrowDown: a.setPoints( 3, border, sqsize / 2, sqsize / 2, sqsize - border, sqsize - border, sqsize / 2 ); break; case QStyle::PE_IndicatorArrowRight: a.setPoints( 3, sqsize - border, sqsize / 2, sqsize / 2, border, sqsize / 2, sqsize - border ); break; case QStyle::PE_IndicatorArrowLeft: a.setPoints( 3, border, sqsize / 2, sqsize / 2, border, sqsize / 2, sqsize - border ); break; default: break; } int bsx = 0; int bsy = 0; if ( opt->state & QStyle::State_Sunken ) { bsx = qApp->style()->pixelMetric( QStyle::PM_ButtonShiftHorizontal ); bsy = qApp->style()->pixelMetric( QStyle::PM_ButtonShiftVertical ); } QRect bounds = a.boundingRect(); int sx = sqsize / 2 - bounds.center().x() - 1; int sy = sqsize / 2 - bounds.center().y() - 1; imagePainter.translate( sx + bsx, sy + bsy ); imagePainter.setPen( opt->palette.buttonText().color() ); imagePainter.setBrush( opt->palette.buttonText() ); if ( !( opt->state & QStyle::State_Enabled ) ) { QColor foreGround( 150, 150, 150, 150 ); imagePainter.setBrush( opt->palette.mid().color() ); imagePainter.setPen( opt->palette.mid().color() ); } else { QColor shadow( 0, 0, 0, 100 ); imagePainter.translate( 0, 1 ); imagePainter.setPen( shadow ); imagePainter.setBrush( shadow ); QColor foreGround( 255, 255, 255, 210 ); imagePainter.drawPolygon( a ); imagePainter.translate( 0, -1 ); imagePainter.setPen( foreGround ); imagePainter.setBrush( foreGround ); } imagePainter.drawPolygon( a ); imagePainter.end(); pixmap = QPixmap::fromImage( image ); QPixmapCache::insert( pixmapName, pixmap ); } int xOffset = r.x() + ( r.width() - size ) / 2; int yOffset = r.y() + ( r.height() - size ) / 2; p->drawPixmap( xOffset, yOffset, pixmap ); }
bool DataManager::readDetectionAreaFile(bool clipToCamera) { QFile areaFile(m_config->detectionAreaFile()); QDomDocument doc; QDomElement root; int x = 0; int y = 0; int cameraId = m_config->cameraIndex(); int cameraWidth = m_config->cameraWidth(); int cameraHeight = m_config->cameraHeight(); QPolygon cameraRectangle; bool polygonsClipped = false; bool polygonWasClosed = false; if(!areaFile.open(QIODevice::ReadOnly | QIODevice::Text)) { QString errorMsg = tr("Failed to open the detection area file %1. Please create it in Settings dialog or manually.").arg(areaFile.fileName()); emit messageBroadcasted(errorMsg); return false; } if(!doc.setContent(&areaFile)) { QString errorMsg = tr("Error reading the detection area file %1").arg(areaFile.fileName()); areaFile.close(); emit messageBroadcasted(errorMsg); return false; } areaFile.close(); root = doc.documentElement(); if (root.nodeName() != "detectionarealist") { QString errorMsg = tr("Expected <detectionarealist> tag in detection area file but not found"); emit messageBroadcasted(errorMsg); return false; } QDomNodeList areaList = root.childNodes(); if (areaList.count() > 1) { QString errorMsg = tr("More than one detection areas defined, combining all together"); emit messageBroadcasted(errorMsg); } for (int i = 0; i < areaList.count(); i++) { QDomNode area = areaList.at(i); QDomNodeList areaNodes = area.childNodes(); if (area.nodeName() != "detectionarea") { QString errorMsg = tr("Expected <detectionarea> tag in detection area file but not found."); emit messageBroadcasted(errorMsg); return false; } QDomNodeList cameraList = area.toElement().elementsByTagName("camera"); if (cameraList.count() != 1) { QString errorMsg = tr("Expected single <camera> tag in detection area. Assuming camera index 0."); emit messageBroadcasted(errorMsg); } for (int c = 0; c < cameraList.count(); c++) { QDomElement cameraElement = cameraList.at(c).toElement(); cameraId = cameraElement.attribute("id").toInt(); cameraWidth = cameraElement.attribute("width").toInt(); cameraHeight = cameraElement.attribute("height").toInt(); if (cameraId == m_config->cameraIndex()) { break; } } cameraRectangle << QPoint(0, 0) << QPoint(0, cameraHeight - 1) << QPoint(cameraWidth - 1, cameraHeight - 1) << QPoint(cameraWidth - 1, 0); while (!m_detectionAreaPolygons.isEmpty()) { QPolygon* polygon = m_detectionAreaPolygons.takeLast(); delete polygon; } for (int a = 0; a < areaNodes.count(); a++) { QDomNode areaSubNode = areaNodes.at(a); if (areaSubNode.nodeName() == "polygon") { QDomNodeList pointList = areaSubNode.childNodes(); QPolygon* polygon = new QPolygon(); for (int p = 0; p < pointList.count(); p++) { QDomElement pointElement = pointList.at(p).toElement(); if (pointElement.nodeName() == "point") { x = pointElement.attribute("x").toInt(); y = pointElement.attribute("y").toInt(); polygon->append(QPoint(x, y)); } } if (clipToCamera && polygon->size() && !cameraRectangle.boundingRect().contains(polygon->boundingRect())) { if (polygon->first() == polygon->last()) { polygonWasClosed = true; } *polygon = polygon->intersected(cameraRectangle); polygonsClipped = true; if (!polygonWasClosed) { // intersected() treats polygon as implicitly closed // so extra node is added: remove it if (polygon->first() == polygon->last()) { polygon->removeLast(); } } } m_detectionAreaPolygons.append(polygon); } } } if (polygonsClipped) { QString warningMsg = tr("Detection area was clipped in order to fit the camera size."); emit messageBroadcasted(warningMsg); } return true; }
C2DPixmapSegment* CDraw2D::doFill(QPoint pt) { if(!hasRegisteredBuffer()) { return 0; } QImage img = m_buffer->toImage(); blankAidBuffer(); if (!checkGradientPoints()) { return 0; } QPainterPath paintPath; QPolygon polygon = algorithm->polygonizeBorder(pt, *m_buffer).toPolygon(); QRect boundingRect = polygon.boundingRect(); QPointF normalizedCenter = CDrawSettings_2D::getInstance()->brushSettings().gradientCenterPoint(); normalizedCenter.setX(normalizedCenter.x() - boundingRect.topLeft().x()); normalizedCenter.setY(normalizedCenter.y() - boundingRect.topLeft().y()); if (normalizedCenter.y() < 0) { normalizedCenter.setY(0); } if (normalizedCenter.y() > boundingRect.height()) { normalizedCenter.setY(boundingRect.height()); } if (normalizedCenter.x() < 0) { normalizedCenter.setX(0); } if (normalizedCenter.x() > boundingRect.width()) { normalizedCenter.setX(boundingRect.width()); } CBrushSettings brs = CDrawSettings_2D::getInstance()->brushSettings(); brs.setGradientCenter(normalizedCenter); QPointF normalizedFocal = CDrawSettings_2D::getInstance()->brushSettings().gradientFocalPoint(); normalizedFocal.setX(normalizedFocal.x() - boundingRect.topLeft().x()); normalizedFocal.setY(normalizedFocal.y() - boundingRect.topLeft().y()); if (normalizedFocal.y() < 0) { normalizedFocal.setY(0); } if (normalizedFocal.y() > boundingRect.height()) { normalizedFocal.setY(boundingRect.height()); } if (normalizedFocal.x() < 0) { normalizedFocal.setX(0); } if (normalizedFocal.x() > boundingRect.width()) { normalizedFocal.setX(boundingRect.width()); } brs.setGradientFocal(normalizedFocal); CDrawSettings_2D::getInstance()->setBrushSettings(brs); QPolygon normalizedPolygon = normalizePolygon(polygon, 0); if (normalizedPolygon.size() > 1) { paintPath.addPolygon(normalizedPolygon); } else { paintPath.addRect(0, 0, m_buffer->width(), m_buffer->height()); } paintPath.closeSubpath(); QSize segmentSize(boundingRect.size().width(), boundingRect.size().height()); QPixmap segmentContent(segmentSize); segmentContent.fill(Qt::transparent); QPainter segmentPainter(&segmentContent); segmentPainter.setRenderHint(QPainter::Antialiasing, _settings.getAntialiasing()); QBrush brush = CDrawSettings_2D::getInstance()->brushSettings().getBrush(); QString summ = explainBrush(brush); //segmentPainter.fillRect(paintPath.boundingRect(), brush); segmentPainter.setPen(CDrawSettings_2D::getInstance()->penSettings().getPen()); segmentPainter.setBrush(brush); segmentPainter.drawPath(paintPath); segmentPainter.end(); //DebugImageDialog DBG(segmentContent); //DBG.exec(); C2DPixmapSegment *segment = new C2DPixmapSegment(&segmentContent, &boundingRect, 1, 0); return segment; }
C2DPixmapSegment* CDraw2D::createSubpixmapFromPolygon(QPolygon &polygon, EPolygonConversion conv) { if(polygon.size() < 2) { return 0; } int sizeOffset = qFloor(static_cast<qreal>(CDrawSettings_2D::getInstance()->penSettings().getWidth())/2.); // get the polygons relative to its bounding rectangle QPolygon normalizedPolygon = normalizePolygon(polygon, sizeOffset); QRect boundingRect = polygon.boundingRect(); QRect normalizedBoundingRect = normalizedPolygon.boundingRect(); QSize segmentSize( boundingRect.size().width() + 2 * sizeOffset + 1, boundingRect.size().height() + 2 * sizeOffset + 1 ); // create segment QPixmap segmentContent(segmentSize); segmentContent.fill(Qt::transparent); QPainter segmentPainter(&segmentContent); segmentPainter.setPen(CDrawSettings_2D::getInstance()->penSettings().getPen()); segmentPainter.setRenderHint(QPainter::Antialiasing,_settings.getAntialiasing()); QPoint firstPt; QPoint secondPt; switch(conv) { case(NO_CONVERSION): segmentPainter.drawPolyline(normalizedPolygon); break; case(TO_LINES): firstPt = normalizedPolygon.at(0); for (int i = 1; i<normalizedPolygon.size(); i++) { secondPt = normalizedPolygon.at(i); if(firstPt == secondPt) { continue; } segmentPainter.drawLine(firstPt, secondPt); firstPt = secondPt; } break; case(TO_RECT): segmentPainter.drawRect(normalizedBoundingRect); break; case(TO_ROUNDED_RECT): segmentPainter.drawRoundedRect( normalizedBoundingRect, CDrawSettings_2D::getInstance()->getRoundedRectRadius_X(), CDrawSettings_2D::getInstance()->getRoundedRectRadius_Y() ); break; case(TO_ELLIPSE): segmentPainter.drawEllipse(normalizedBoundingRect); break; case(TO_PIE): segmentPainter.drawPie(normalizedBoundingRect, alphaDegrees * 16, betaDegrees * 16); break; case(TO_ARC): segmentPainter.drawArc(normalizedBoundingRect, alphaDegrees * 16, betaDegrees * 16); break; case(TO_CHORD): segmentPainter.drawChord(normalizedBoundingRect, alphaDegrees * 16, betaDegrees * 16); break; default: segmentPainter.drawPolyline(normalizedPolygon); break; } segmentPainter.end(); //DebugImageDialog DBG(segmentContent); //DBG.exec(); C2DPixmapSegment *segment = new C2DPixmapSegment(&segmentContent, &boundingRect, 1, sizeOffset); return segment; }
/*! * parameters of polygons may vary depending on whether poly is selected or not or * whether it's label is main or not. */ void ImageHolder::drawPolygons( QPainter *aPainter, QPen *aPen ) const { if (0 == list_polygon_) { return; /* NOTREACHED */ } Qt::PenStyle penStyle = Qt::SolidLine; /* default width is hardcoded */ int width = 2; /* drawing all the polygons */ for (int i = 0; i < list_polygon_->size(); i++) { penStyle = Qt::SolidLine; int labelID = list_polygon_->at(i)->label_ID_; /* setting color for the label of current bbox */ if (labelID < list_label_color_->count()) aPen->setColor(QColor(list_label_color_->at(labelID))); /* in case there is no color for such label */ else aPen->setColor(QColor(Qt::white)); /* checking whether labeled area is of main object or not */ if (labelID == *main_label_) width = 3; else width = 2; /* changing the line style and width if current area is selected(focused) */ if (PolyFigure == focused_selection_type_ && focused_selection_ == i) { penStyle = Qt::DotLine; width = 3; } QPoint point; QPolygon poly = list_polygon_->at(i)->poly; for (int j = 0; j < poly.size(); j++) { point.setX(poly.at(j).x()); point.setY(poly.at(j).y()); /* scaling */ point *= scale_; poly.remove(j); poly.insert(j, point); /* in case if it's focused */ if (focused_selection_ == i && focused_selection_type_ == PolyFigure) { QPen circPen; circPen.setWidth(2); circPen.setStyle(Qt::SolidLine); circPen.setColor(aPen->color()); aPainter->setPen(circPen); /* filling the point if it is hovered */ if ((j == hovered_point_.pointID && i == hovered_point_.figureID && PolyFigure == hovered_point_.figure) || j == selected_point_) { QBrush brush; brush.setColor(aPen->color()); brush.setStyle(Qt::SolidPattern); aPainter->setBrush(brush); } aPainter->drawEllipse(point, point_radius_, point_radius_); aPainter->setBrush(Qt::NoBrush); } } aPen->setWidth(width); aPen->setStyle(penStyle); aPainter->setPen(*aPen); aPainter->drawPolygon(poly); /* drawing label IDs of these polygons */ QString labelIDText = QString("%1").arg(labelID); QRect rect = poly.boundingRect(); int x = rect.center().x(); int y = rect.center().y(); aPainter->drawText( x, y, 20, 20, Qt::AlignHCenter, labelIDText ); } }
void FreeRegionGrabber::paintEvent( QPaintEvent* e ) { Q_UNUSED( e ); if ( grabbing ) // grabWindow() should just get the background return; QPainter painter( this ); QPalette pal(QToolTip::palette()); QFont font = QToolTip::font(); QColor handleColor = pal.color( QPalette::Active, QPalette::Highlight ); handleColor.setAlpha( 160 ); QColor overlayColor( 0, 0, 0, 160 ); QColor textColor = pal.color( QPalette::Active, QPalette::Text ); QColor textBackgroundColor = pal.color( QPalette::Active, QPalette::Base ); painter.drawPixmap(0, 0, pixmap); painter.setFont(font); QPolygon pol = selection; if ( !selection.boundingRect().isNull() ) { // Draw outline around selection. // Important: the 1px-wide outline is *also* part of the captured free-region because // I found no way to draw the outline *around* the selection because I found no way // to create a QPolygon which is smaller than the selection by 1px (QPolygon::translated // is NOT equivalent to QRect::adjusted) QPen pen(handleColor, 1, Qt::SolidLine, Qt::SquareCap, Qt::BevelJoin); painter.setPen(pen); painter.drawPolygon( pol ); // Draw the grey area around the selection QRegion grey( rect() ); grey = grey - pol; painter.setClipRegion( grey ); painter.setPen( Qt::NoPen ); painter.setBrush( overlayColor ); painter.drawRect( rect() ); painter.setClipRect( rect() ); drawPolygon( &painter, pol, handleColor); } if ( showHelp ) { painter.setPen( textColor ); painter.setBrush( textBackgroundColor ); QString helpText = i18n( "Select a region using the mouse. To take the snapshot, press the Enter key or double click. Press Esc to quit." ); helpTextRect = painter.boundingRect( rect().adjusted( 2, 2, -2, -2 ), Qt::TextWordWrap, helpText ); helpTextRect.adjust( -2, -2, 4, 2 ); drawPolygon( &painter, helpTextRect, textColor, textBackgroundColor ); painter.drawText( helpTextRect.adjusted( 3, 3, -3, -3 ), helpText ); } if ( selection.isEmpty() ) { return; } // The grabbed region is everything which is covered by the drawn // rectangles (border included). This means that there is no 0px // selection, since a 0px wide rectangle will always be drawn as a line. QString txt = QString( "%1x%2" ).arg( selection.boundingRect().width() ) .arg( selection.boundingRect().height() ); QRect textRect = painter.boundingRect( rect(), Qt::AlignLeft, txt ); QRect boundingRect = textRect.adjusted( -4, 0, 0, 0); if ( textRect.width() < pol.boundingRect().width() - 2*handleSize && textRect.height() < pol.boundingRect().height() - 2*handleSize && ( pol.boundingRect().width() > 100 && pol.boundingRect().height() > 100 ) ) // center, unsuitable for small selections { boundingRect.moveCenter( pol.boundingRect().center() ); textRect.moveCenter( pol.boundingRect().center() ); } else if ( pol.boundingRect().y() - 3 > textRect.height() && pol.boundingRect().x() + textRect.width() < rect().right() ) // on top, left aligned { boundingRect.moveBottomLeft( QPoint( pol.boundingRect().x(), pol.boundingRect().y() - 3 ) ); textRect.moveBottomLeft( QPoint( pol.boundingRect().x() + 2, pol.boundingRect().y() - 3 ) ); } else if ( pol.boundingRect().x() - 3 > textRect.width() ) // left, top aligned { boundingRect.moveTopRight( QPoint( pol.boundingRect().x() - 3, pol.boundingRect().y() ) ); textRect.moveTopRight( QPoint( pol.boundingRect().x() - 5, pol.boundingRect().y() ) ); } else if ( pol.boundingRect().bottom() + 3 + textRect.height() < rect().bottom() && pol.boundingRect().right() > textRect.width() ) // at bottom, right aligned { boundingRect.moveTopRight( QPoint( pol.boundingRect().right(), pol.boundingRect().bottom() + 3 ) ); textRect.moveTopRight( QPoint( pol.boundingRect().right() - 2, pol.boundingRect().bottom() + 3 ) ); } else if ( pol.boundingRect().right() + textRect.width() + 3 < rect().width() ) // right, bottom aligned { boundingRect.moveBottomLeft( QPoint( pol.boundingRect().right() + 3, pol.boundingRect().bottom() ) ); textRect.moveBottomLeft( QPoint( pol.boundingRect().right() + 5, pol.boundingRect().bottom() ) ); } // if the above didn't catch it, you are running on a very tiny screen... drawPolygon( &painter, boundingRect, textColor, textBackgroundColor ); painter.drawText( textRect, txt ); if ( ( pol.boundingRect().height() > handleSize*2 && pol.boundingRect().width() > handleSize*2 ) || !mouseDown ) { painter.setBrush(QBrush(Qt::transparent)); painter.setClipRegion( QRegion(pol)); painter.drawPolygon( rect() ); } }
void ManhattanStyle::drawPrimitive(PrimitiveElement element, const QStyleOption *option, QPainter *painter, const QWidget *widget) const { if (!panelWidget(widget)) return d->style->drawPrimitive(element, option, painter, widget); bool animating = (option->state & State_Animating); int state = option->state; QRect rect = option->rect; QRect oldRect; QRect newRect; if (widget && (element == PE_PanelButtonTool) && !animating) { QWidget *w = const_cast<QWidget *> (widget); int oldState = w->property("_q_stylestate").toInt(); oldRect = w->property("_q_stylerect").toRect(); newRect = w->rect(); w->setProperty("_q_stylestate", (int)option->state); w->setProperty("_q_stylerect", w->rect()); // Determine the animated transition bool doTransition = ((state & State_On) != (oldState & State_On) || (state & State_MouseOver) != (oldState & State_MouseOver)); if (oldRect != newRect) { doTransition = false; d->animator.stopAnimation(widget); } if (doTransition) { QImage startImage(option->rect.size(), QImage::Format_ARGB32_Premultiplied); QImage endImage(option->rect.size(), QImage::Format_ARGB32_Premultiplied); Animation *anim = d->animator.widgetAnimation(widget); QStyleOption opt = *option; opt.state = (QStyle::State)oldState; opt.state |= (State)State_Animating; startImage.fill(0); Transition *t = new Transition; t->setWidget(w); QPainter startPainter(&startImage); if (!anim) { drawPrimitive(element, &opt, &startPainter, widget); } else { anim->paint(&startPainter, &opt); d->animator.stopAnimation(widget); } QStyleOption endOpt = *option; endOpt.state |= (State)State_Animating; t->setStartImage(startImage); d->animator.startAnimation(t); endImage.fill(0); QPainter endPainter(&endImage); drawPrimitive(element, &endOpt, &endPainter, widget); t->setEndImage(endImage); t->setDuration(130); t->setStartTime(QTime::currentTime()); } } switch (element) { case PE_PanelLineEdit: { painter->save(); if (option->state & State_Enabled) drawCornerImage(d->lineeditImage, painter, option->rect, 2, 2, 2, 2); else drawCornerImage(d->lineeditImage_disabled, painter, option->rect, 2, 2, 2, 2); if (option->state & State_HasFocus || option->state & State_MouseOver) { QColor hover = StyleHelper::baseColor(); if (state & State_HasFocus) hover.setAlpha(100); else hover.setAlpha(50); painter->setPen(QPen(hover, 1)); painter->drawRect(option->rect.adjusted(1, 1, -2 ,-2)); } painter->restore(); } break; case PE_FrameStatusBarItem: break; case PE_PanelButtonTool: { Animation *anim = d->animator.widgetAnimation(widget); if (!animating && anim) { anim->paint(painter, option); } else { bool pressed = option->state & State_Sunken || option->state & State_On; QColor shadow(0, 0, 0, 30); painter->setPen(shadow); if (pressed) { QColor shade(0, 0, 0, 40); painter->fillRect(rect, shade); painter->drawLine(rect.topLeft() + QPoint(1, 0), rect.topRight() - QPoint(1, 0)); painter->drawLine(rect.topLeft(), rect.bottomLeft()); painter->drawLine(rect.topRight(), rect.bottomRight()); // painter->drawLine(rect.bottomLeft() + QPoint(1, 0), rect.bottomRight() - QPoint(1, 0)); QColor highlight(255, 255, 255, 30); painter->setPen(highlight); } else if (option->state & State_Enabled && option->state & State_MouseOver) { QColor lighter(255, 255, 255, 37); painter->fillRect(rect, lighter); } } } break; case PE_PanelStatusBar: { painter->save(); QLinearGradient grad(option->rect.topLeft(), QPoint(rect.center().x(), rect.bottom())); QColor startColor = StyleHelper::shadowColor().darker(164); QColor endColor = StyleHelper::baseColor().darker(130); grad.setColorAt(0, endColor); grad.setColorAt(1, endColor); painter->fillRect(option->rect, grad); painter->setPen(QColor(255, 255, 255, 60)); painter->drawLine(rect.topLeft() + QPoint(0,1), rect.topRight()+ QPoint(0,1)); painter->setPen(StyleHelper::borderColor().darker(110)); painter->drawLine(rect.topLeft(), rect.topRight()); painter->restore(); } break; case PE_IndicatorToolBarSeparator: { QColor separatorColor = StyleHelper::borderColor(); separatorColor.setAlpha(100); painter->setPen(separatorColor); const int margin = 3; if (option->state & State_Horizontal) { const int offset = rect.width()/2; painter->drawLine(rect.bottomLeft().x() + offset, rect.bottomLeft().y() - margin, rect.topLeft().x() + offset, rect.topLeft().y() + margin); } else { //Draw vertical separator const int offset = rect.height()/2; painter->setPen(QPen(option->palette.background().color().darker(110))); painter->drawLine(rect.topLeft().x() + margin , rect.topLeft().y() + offset, rect.topRight().x() - margin, rect.topRight().y() + offset); } } break; case PE_IndicatorToolBarHandle: { bool horizontal = option->state & State_Horizontal; painter->save(); QPainterPath path; int x = option->rect.x() + horizontal ? 2 : 6; int y = option->rect.y() + horizontal ? 6 : 2; static const int RectHeight = 2; if (horizontal) { while (y < option->rect.height() - RectHeight - 6) { path.moveTo(x, y); path.addRect(x, y, RectHeight, RectHeight); y += 6; } } else { while (x < option->rect.width() - RectHeight - 6) { path.moveTo(x, y); path.addRect(x, y, RectHeight, RectHeight); x += 6; } } painter->setPen(Qt::NoPen); QColor dark = StyleHelper::borderColor(); dark.setAlphaF(0.4); QColor light = StyleHelper::baseColor(); light.setAlphaF(0.4); painter->fillPath(path, light); painter->save(); painter->translate(1, 1); painter->fillPath(path, dark); painter->restore(); painter->translate(3, 3); painter->fillPath(path, light); painter->translate(1, 1); painter->fillPath(path, dark); painter->restore(); } break; case PE_IndicatorArrowUp: case PE_IndicatorArrowDown: case PE_IndicatorArrowRight: case PE_IndicatorArrowLeft: { // From windowsstyle but modified to enable AA if (option->rect.width() <= 1 || option->rect.height() <= 1) break; QRect r = option->rect; int size = qMin(r.height(), r.width()); QPixmap pixmap; QString pixmapName; pixmapName.sprintf("%s-%s-%d-%d-%d-%lld", "$qt_ia", metaObject()->className(), uint(option->state), element, size, option->palette.cacheKey()); if (!QPixmapCache::find(pixmapName, pixmap)) { int border = size/5; int sqsize = 2*(size/2); QImage image(sqsize, sqsize, QImage::Format_ARGB32); image.fill(Qt::transparent); QPainter imagePainter(&image); imagePainter.setRenderHint(QPainter::Antialiasing, true); imagePainter.translate(0.5, 0.5); QPolygon a; switch (element) { case PE_IndicatorArrowUp: a.setPoints(3, border, sqsize/2, sqsize/2, border, sqsize - border, sqsize/2); break; case PE_IndicatorArrowDown: a.setPoints(3, border, sqsize/2, sqsize/2, sqsize - border, sqsize - border, sqsize/2); break; case PE_IndicatorArrowRight: a.setPoints(3, sqsize - border, sqsize/2, sqsize/2, border, sqsize/2, sqsize - border); break; case PE_IndicatorArrowLeft: a.setPoints(3, border, sqsize/2, sqsize/2, border, sqsize/2, sqsize - border); break; default: break; } int bsx = 0; int bsy = 0; if (option->state & State_Sunken) { bsx = pixelMetric(PM_ButtonShiftHorizontal); bsy = pixelMetric(PM_ButtonShiftVertical); } QRect bounds = a.boundingRect(); int sx = sqsize / 2 - bounds.center().x() - 1; int sy = sqsize / 2 - bounds.center().y() - 1; imagePainter.translate(sx + bsx, sy + bsy); if (!(option->state & State_Enabled)) { QColor foreGround(150, 150, 150, 150); imagePainter.setBrush(option->palette.mid().color()); imagePainter.setPen(option->palette.mid().color()); } else { QColor shadow(0, 0, 0, 100); imagePainter.translate(0, 1); imagePainter.setPen(shadow); imagePainter.setBrush(shadow); QColor foreGround(255, 255, 255, 210); imagePainter.drawPolygon(a); imagePainter.translate(0, -1); imagePainter.setPen(foreGround); imagePainter.setBrush(foreGround); } imagePainter.drawPolygon(a); imagePainter.end(); pixmap = QPixmap::fromImage(image); QPixmapCache::insert(pixmapName, pixmap); } int xOffset = r.x() + (r.width() - size)/2; int yOffset = r.y() + (r.height() - size)/2; painter->drawPixmap(xOffset, yOffset, pixmap); } break; default: d->style->drawPrimitive(element, option, painter, widget); break; } }
/*! Calculate the mask for the rubber band overlay \return Region for the mask \sa QWidget::setMask() */ QRegion QwtPicker::rubberBandMask() const { QRegion mask; if ( !isActive() || rubberBand() == NoRubberBand || rubberBandPen().style() == Qt::NoPen ) { return mask; } const QPolygon pa = adjustedPoints( d_data->pickedPoints ); QwtPickerMachine::SelectionType selectionType = QwtPickerMachine::NoSelection; if ( d_data->stateMachine ) selectionType = d_data->stateMachine->selectionType(); switch ( selectionType ) { case QwtPickerMachine::NoSelection: case QwtPickerMachine::PointSelection: { if ( pa.count() < 1 ) return mask; const QPoint pos = pa[0]; const int pw = rubberBandPen().width(); const QRect pRect = pickArea().boundingRect().toRect(); switch ( rubberBand() ) { case VLineRubberBand: { mask += qwtMaskRegion( QLine( pos.x(), pRect.top(), pos.x(), pRect.bottom() ), pw ); break; } case HLineRubberBand: { mask += qwtMaskRegion( QLine( pRect.left(), pos.y(), pRect.right(), pos.y() ), pw ); break; } case CrossRubberBand: { mask += qwtMaskRegion( QLine( pos.x(), pRect.top(), pos.x(), pRect.bottom() ), pw ); mask += qwtMaskRegion( QLine( pRect.left(), pos.y(), pRect.right(), pos.y() ), pw ); break; } default: break; } break; } case QwtPickerMachine::RectSelection: { if ( pa.count() < 2 ) return mask; const int pw = rubberBandPen().width(); switch ( rubberBand() ) { case RectRubberBand: { const QRect r = QRect( pa.first(), pa.last() ); mask = qwtMaskRegion( r.normalized(), pw ); break; } case EllipseRubberBand: { const QRect r = QRect( pa.first(), pa.last() ); mask += r.adjusted( -pw, -pw, pw, pw ); break; } default: break; } break; } case QwtPickerMachine::PolygonSelection: { const int pw = rubberBandPen().width(); if ( pw <= 1 ) { // because of the join style we better // return a mask for a pen width <= 1 only const int off = 2 * pw; const QRect r = pa.boundingRect(); mask += r.adjusted( -off, -off, off, off ); } break; } default: break; } return mask; }