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;
}