QPainterPath
Shapes::stick(const QRectF &bound, Style style)
{
_S(6)
QPainterPath path;
switch (style)
{
case Square:
path.addRect(bound.adjusted(s6, s6, -s6, -s6));
break;
case LasseKongo:
{
_S(4);
const float d = 3*s4;
QRectF rect = bound.adjusted(0,0,-d,-d);
path.addRect(rect);
path.addRect(rect.translated(d,0));
path.addRect(rect.translated(0,d));
path.addRect(rect.translated(d,d));
break;
}
default:
case Round:
case TheRob:
path.addEllipse(bound.adjusted(s6, s6, -s6, -s6));
break;
}
return path;
}
void GraphicsDImgView::drawText(QPainter* p, const QRectF& rect, const QString& text)
{
p->save();
p->setRenderHint(QPainter::Antialiasing, true);
p->setBackgroundMode(Qt::TransparentMode);
// increase width by 5 and height by 2
QRectF textRect = rect.adjusted(0, 0, 5, 2);
// Draw background
p->setPen(Qt::black);
QColor semiTransBg = palette().color(QPalette::Window);
semiTransBg.setAlpha(190);
p->setBrush(semiTransBg);
//p->translate(0.5, 0.5);
p->drawRoundRect(textRect, 10.0, 10.0);
// Draw shadow and text
p->setPen(palette().color(QPalette::Window).dark(115));
p->drawText(textRect.translated(3, 1), text);
p->setPen(palette().color(QPalette::WindowText));
p->drawText(textRect.translated(2, 0), text);
p->restore();
}
void WeatherWallpaper::paint(QPainter * painter, const QRectF & exposedRect)
{
// Check if geometry changed
if (m_size != boundingRect().size().toSize()) {
calculateGeometry();
if (!m_size.isEmpty() && !m_img.isEmpty()) { // We have previous image
renderWallpaper();
return;
}
}
if (m_pixmap.isNull()) {
painter->fillRect(exposedRect, QBrush(m_color));
return;
}
if (painter->worldMatrix() == QMatrix()) {
// draw the background untransformed when possible;(saves lots of per-pixel-math)
painter->resetTransform();
}
// blit the background (saves all the per-pixel-products that blending does)
painter->setCompositionMode(QPainter::CompositionMode_Source);
// for pixmaps we draw only the exposed part (untransformed since the
// bitmapBackground already has the size of the viewport)
painter->drawPixmap(exposedRect, m_pixmap, exposedRect.translated(-boundingRect().topLeft()));
if (!m_oldFadedPixmap.isNull()) {
// Put old faded image on top.
painter->setCompositionMode(QPainter::CompositionMode_SourceAtop);
painter->drawPixmap(exposedRect, m_oldFadedPixmap,
exposedRect.translated(-boundingRect().topLeft()));
}
}
void ResizeCommand::resize(NodeElement * const element, const QRectF &geometry)
{
if (element && geometryOf(element) != geometry) {
ResizeHandler handler(element);
handler.resize(geometry.translated(-geometry.topLeft()), geometry.topLeft(), false);
}
}
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 );
*/
}
QRectF PheromoneItem::calculateTextRect(const QString &str, const QFont &font, const QRectF &referencia)
{
// QFont font("arial", 7);
QFontMetricsF txtMetrics(font);
QRectF tmpRect = txtMetrics.boundingRect(str);
return tmpRect.translated(-tmpRect.width()/2, referencia.y() - tmpRect.height());
}
QImage TwoDModelEngineApi::printColorSensor(PortInfo const &port) const
{
if (mModel.robotModel().configuration().type(port).isNull()) {
return QImage();
}
QPair<QPointF, qreal> const neededPosDir = countPositionAndDirection(port);
QPointF const position = neededPosDir.first;
qreal const width = sensorWidth / 2.0;
QRectF const scanningRect = QRectF(position.x() - width, position.y() - width, 2 * width, 2 * width);
QImage image(scanningRect.size().toSize(), QImage::Format_RGB32);
QPainter painter(&image);
QBrush brush(Qt::SolidPattern);
brush.setColor(Qt::white);
painter.setBrush(brush);
painter.setPen(QPen(Qt::white));
painter.drawRect(scanningRect.translated(-scanningRect.topLeft()));
bool const wasSelected = mView.sensorItem(port)->isSelected();
mView.setSensorVisible(port, false);
mView.scene()->render(&painter, QRectF(), scanningRect);
mView.setSensorVisible(port, true);
mView.sensorItem(port)->setSelected(wasSelected);
return image;
}
QPainterPath
Shapes::keepBelow(const QRectF &bound, Style style)
{
_S(2) _S(3) _S(4)
QPainterPath path;
switch (style)
{
case Square:
case LasseKongo:
path.addRect(bound.adjusted(s4, 2*s3, -s4, 0));
path.addRect(bound.adjusted(0, 0, -2*s3, -2*s3));
path.addRect(bound.adjusted(2*s3, 0, 0, -2*s3));
break;
default:
case Round:
case TheRob:
QRectF rect = bound.adjusted(0, 0, -s2, -s2);
path.moveTo(bound.center() + QPointF(0, s2));
path.arcTo(bound.translated(0, s2), 0, 180);
path.closeSubpath();
path.moveTo(rect.center());
path.arcTo(rect, 0, 180);
path.closeSubpath();
rect.translate(s2, 0);
path.moveTo(rect.center());
path.arcTo(rect, 0, 180);
path.closeSubpath();
break;
}
return path;
}
QRectF ShadowEffect::boundingRectFor(const QRectF &rect) const
{
qreal padding = m_blurRadius * 2;
return rect.united(
rect.translated(m_xOffset, m_yOffset)
.adjusted(-padding, -padding, padding, padding)
);
}
void EditorMagnifierItem::paint(QPainter * painter,
const QStyleOptionGraphicsItem *option,
QWidget * widget)
{
Q_UNUSED(option);
Q_UNUSED(widget);
if ( !scene() )
return;
QRectF rect = getRect();
EditorScene *scn = qobject_cast<EditorScene *>( scene() );
if (rect.isValid() && m_valid && scn)
{
updateMask();
painter->save(); // because clipping is active !!
QPainterPath clipPath;
clipPath.addEllipse(getRect().center(), getRect().width() / 2,getRect().width() / 2);
painter->setClipPath(clipPath);
painter->setClipping(true);
// TODO add extracted image to a cache !!!
QRectF extractRect( rect.translated( pos() - scn->getUnderlayOffset() ) );
int extractWidth = extractRect.width() / m_magnifyingFactor;
extractRect.adjust(extractWidth,extractWidth,-extractWidth,-extractWidth);
QRectF bgRect = scn->getUnderlayImage().rect();
QRectF croppedRect = extractRect.intersected(bgRect);
if ( !croppedRect.isNull() )
{
QImage background = scn->getUnderlayImage().copy( croppedRect.toRect() );
QImage mag = background.scaled(rect.size().toSize(),Qt::KeepAspectRatio,Qt::SmoothTransformation);
painter->drawImage(rect,mag);
}
painter->drawPixmap(rect.topLeft(), m_imgMask);
painter->restore();
}
// draw a box if selected
if( isSelected() )
{
painter->save();
QPen pen;
pen.setCosmetic(true);
pen.setColor(Qt::black);
pen.setWidth(1);
pen.setStyle(Qt::DotLine);
painter->setPen(pen);
painter->drawRect(rect);
painter->restore();
}
}
QRectF CenterRectSlaveFromMaster( const QRectF Master ,
QRectF Slave )
{
QRectF SlaveOnline = Slave.translated(Master.center());
const qreal wi = Slave.width() / 2;
const qreal hi = Slave.height() / 2;
SlaveOnline.translate( 0 - wi , 0 - hi );
return SlaveOnline;
}
QRectF CDiagramTextNode::contentsRect() const
{
QRectF r;
r = CDiagramNode::contentsRect();
if (m_coordMode != CDiagramItem::CenterAsOrigin)
r = r.translated( -r.topLeft() );
return r;
}
void ChannelGraphItem::paint(QPainter* painter, QColor color)
{
QRectF rect = boundingRect();
QLinearGradient gradient(rect.topLeft(), rect.bottomLeft());
gradient.setColorAt(0, QColor(255, 255, 255));
gradient.setColorAt(1, color);
painter->setBrush(gradient);
painter->drawRoundedRect(rect, margin, margin);
painter->drawText(rect.translated(1, -1), Qt::AlignCenter, name);
}
QRectF KisExperimentPaintOpSettings::paintOutlineRect(const QPointF& pos, KisImageWSP image, OutlineMode _mode) const
{
if (_mode != CursorIsOutline) return QRectF();
qreal width = getInt(EXPERIMENT_START_SIZE); /* scale();*/
qreal height = getInt(EXPERIMENT_START_SIZE); /* scale();*/
width += 10;
height += 10;
QRectF rc = QRectF(0, 0, width, height);
return image->pixelToDocument(rc.translated(- QPoint(width * 0.5, height * 0.5))).translated(pos);
}
void D2ModelScene::centerOnRobot()
{
for (QGraphicsView * const view : views()) {
QRectF const viewPortRect = view->mapToScene(view->viewport()->rect()).boundingRect();
if (!viewPortRect.contains(mRobot->sceneBoundingRect().toRect())) {
QRectF const requiredViewPort = viewPortRect.translated(mRobot->scenePos() - viewPortRect.center());
setSceneRect(itemsBoundingRect().united(requiredViewPort));
view->centerOn(mRobot);
}
}
}
void NodeElement::setGeometry(const QRectF &geom)
{
prepareGeometryChange();
setPos(geom.topLeft());
if (geom.isValid()) {
mContents = geom.translated(-geom.topLeft());
}
mTransform.reset();
mTransform.scale(mContents.width(), mContents.height());
adjustLinks();
}
void MultipleInputItem::interPaint(QPainter* _p, const QStyleOptionGraphicsItem*, QWidget*)
{
QString s = m_multiplicity != Undefined ? QString::number(m_multiplicity) : "?";
QFont f;
f.setBold(true);
QRectF br = boundingRect().adjusted(m_size.height() / 2 + 4, 4, -4, -4);
f.setPixelSize(br.height());
_p->setFont(f);
_p->setPen(QColor(0, 0, 0, 96));
_p->drawText(br.translated(0, 1), Qt::AlignCenter, s);
_p->setPen(Qt::white);
_p->drawText(br, Qt::AlignCenter, s);
}
void KWCanvasBase::paint(QPainter &painter, const QRectF &paintRect)
{
painter.translate(-m_documentOffset);
static int iteration = 0;
iteration++;
if (m_viewMode->hasPages()) {
int pageContentArea = 0;
if (!m_cacheEnabled || !m_pageCacheManager) { // no caching, simple case
QList<KWViewMode::ViewMap> map =
m_viewMode->mapExposedRects(paintRect.translated(m_documentOffset),
viewConverter());
foreach (KWViewMode::ViewMap vm, map) {
painter.save();
// Set up the painter to clip the part of the canvas that contains the rect.
painter.translate(vm.distance.x(), vm.distance.y());
vm.clipRect = vm.clipRect.adjusted(-1, -1, 1, 1);
painter.setClipRect(vm.clipRect);
// Paint the background of the page.
QColor color = Qt::white;
#ifdef DEBUG_REPAINT
color = QColor(random() % 255, random() % 255, random() % 255);
#endif
painter.fillRect(vm.clipRect, QBrush(color));
// Paint the contents of the page.
painter.setRenderHint(QPainter::Antialiasing);
m_shapeManager->paint(painter, *(viewConverter()), false); // Paint all shapes
paintBorder(painter, vm);
// Paint the page decorations: shadow, etc.
paintPageDecorations(painter, vm);
// Paint the grid
paintGrid(painter, vm);
// paint whatever the tool wants to paint
m_toolProxy->paint(painter, *(viewConverter()));
painter.restore();
int contentArea = vm.clipRect.width() * vm.clipRect.height();
if (contentArea > pageContentArea) {
pageContentArea = contentArea;
}
}
void PatienceView::drawBackground( QPainter * painter, const QRectF & rect )
{
QRectF source = rect.translated( -sceneRect().topLeft() );
if ( m_background.size() != size() )
{
qreal xScale = m_background.width() / width();
qreal yScale = m_background.height() / height();
source = QRectF( source.x() * xScale,
source.y() * yScale,
source.width() * xScale,
source.height() * yScale );
}
painter->drawPixmap( rect, m_background, source );
}
QRectF KisDuplicateOpSettings::paintOutlineRect(const QPointF& pos, KisImageWSP image, OutlineMode _mode) const
{
/*QRectF dubRect = duplicateOutlineRect(pos, image);
if (_mode == CursorIsOutline) {
dubRect |= KisBrushBasedPaintOpSettings::paintOutlineRect(pos, image, _mode);
}
return dubRect;*/
if (_mode != CursorIsOutline) return QRectF();
QPointF hotSpot = KisBrushBasedPaintOpSettings::brushOutline(pos,_mode).boundingRect().center();
QRectF boundRect = brushOutline(pos,_mode).boundingRect();
return image->pixelToDocument(boundRect.translated(-hotSpot)).translated(pos);
}
static bool intersect_rect(const QGraphicsItem *item, const QRectF &exposeRect, Qt::ItemSelectionMode mode,
const QTransform &deviceTransform, const void *intersectData)
{
const QRectF sceneRect = *static_cast<const QRectF *>(intersectData);
QRectF brect = item->boundingRect();
_q_adjustRect(&brect);
// ### Add test for this (without making things slower?)
Q_UNUSED(exposeRect);
bool keep = true;
const QGraphicsItemPrivate *itemd = QGraphicsItemPrivate::get(item);
if (itemd->itemIsUntransformable()) {
// Untransformable items; map the scene rect to item coordinates.
const QTransform transform = item->deviceTransform(deviceTransform);
QRectF itemRect = (deviceTransform * transform.inverted()).mapRect(sceneRect);
if (mode == Qt::ContainsItemShape || mode == Qt::ContainsItemBoundingRect)
keep = itemRect.contains(brect) && itemRect != brect;
else
keep = itemRect.intersects(brect);
if (keep && (mode == Qt::ContainsItemShape || mode == Qt::IntersectsItemShape)) {
QPainterPath itemPath;
itemPath.addRect(itemRect);
keep = QGraphicsSceneIndexPrivate::itemCollidesWithPath(item, itemPath, mode);
}
} else {
Q_ASSERT(!itemd->dirtySceneTransform);
const QRectF itemSceneBoundingRect = itemd->sceneTransformTranslateOnly
? brect.translated(itemd->sceneTransform.dx(),
itemd->sceneTransform.dy())
: itemd->sceneTransform.mapRect(brect);
if (mode == Qt::ContainsItemShape || mode == Qt::ContainsItemBoundingRect)
keep = sceneRect != brect && sceneRect.contains(itemSceneBoundingRect);
else
keep = sceneRect.intersects(itemSceneBoundingRect);
if (keep && (mode == Qt::ContainsItemShape || mode == Qt::IntersectsItemShape)) {
QPainterPath rectPath;
rectPath.addRect(sceneRect);
if (itemd->sceneTransformTranslateOnly)
rectPath.translate(-itemd->sceneTransform.dx(), -itemd->sceneTransform.dy());
else
rectPath = itemd->sceneTransform.inverted().map(rectPath);
keep = QGraphicsSceneIndexPrivate::itemCollidesWithPath(item, rectPath, mode);
}
}
return keep;
}
QGraphicsItem * EnvelopeClient::createGraphicsItem()
{
int padding = 4;
QGraphicsRectItem *item = new QGraphicsRectItem();
ParameterGraphicsItem *parameterItem = new ParameterGraphicsItem(this);
QRectF rect = QRect(0, 0, 1200, 420);
rect = rect.translated(parameterItem->boundingRect().width() + 2 * padding, padding);
parameterItem->setPos(padding, padding);
parameterItem->setParentItem(item);
EnvelopeGraphicsItem *ourItem = new EnvelopeGraphicsItem(rect, this, item);
item->setRect((rect | parameterItem->boundingRect().translated(parameterItem->pos())).adjusted(-padding, -padding, padding, padding));
item->setPen(QPen(QBrush(Qt::black), 1));
item->setBrush(QBrush(Qt::white));
QObject::connect(this, SIGNAL(changedYSteps(int)), ourItem, SLOT(setHorizontalSlices(int)));
return item;
}
void BitmapImage::drawEllipse( QRectF rectangle, QPen pen, QBrush brush, QPainter::CompositionMode cm, bool antialiasing)
{
int width = pen.width();
extend( rectangle.adjusted(-width,-width,width,width).toRect() );
if (image != NULL && !image->isNull() )
{
QPainter painter(image);
painter.setCompositionMode(cm);
painter.setRenderHint(QPainter::Antialiasing, antialiasing);
painter.setPen(pen);
painter.setBrush(brush);
//if (brush == Qt::NoBrush)
painter.drawEllipse( rectangle.translated(-topLeft()) );
painter.end();
}
}
QRectF ZoomHelper::toTilesArea(const QRectF& windowArea,
const QSize& tilesSurface) const
{
const auto contentRect = getContentRect();
// Map window visibleArea to content space for tiles origin at (0,0)
const auto visibleContentArea =
windowArea.translated(-contentRect.x(), -contentRect.y());
// Scale content area to tiles area size
const auto xScale = tilesSurface.width() / contentRect.width();
const auto yScale = tilesSurface.height() / contentRect.height();
const auto visibleTilesArea =
QRectF{visibleContentArea.x() * xScale, visibleContentArea.y() * yScale,
visibleContentArea.width() * xScale,
visibleContentArea.height() * yScale};
return visibleTilesArea;
}
void TwoDModelScene::centerOnRobot(RobotItem *selectedItem)
{
RobotItem *robotItem = mRobots.values().first();
if (selectedItem) {
robotItem = selectedItem;
}
for (QGraphicsView * const view : views()) {
const QRectF viewPortRect = view->mapToScene(view->viewport()->rect()).boundingRect();
if (!viewPortRect.contains(robotItem->sceneBoundingRect().toRect())) {
const QRectF requiredViewPort = viewPortRect.translated(robotItem->scenePos() - viewPortRect.center());
setSceneRect(itemsBoundingRect().united(requiredViewPort));
view->centerOn(robotItem);
}
}
}
void KPrViewModeNotes::paint(KoPACanvasBase* canvas, QPainter& painter, const QRectF &paintRect)
{
#ifdef NDEBUG
Q_UNUSED(canvas);
#endif
Q_ASSERT( m_canvas == canvas );
painter.translate(-m_canvas->documentOffset());
painter.setRenderHint( QPainter::Antialiasing );
QRectF clipRect = paintRect.translated(m_canvas->documentOffset());
painter.setClipRect( clipRect );
KoViewConverter *converter = m_view->viewConverter( m_canvas );
m_canvas->shapeManager()->paint(painter, *converter, false);
m_toolProxy->paint(painter, *converter);
}
void MapScene::drawForeground(QPainter *painter, const QRectF &rect)
{
if (!mMapDocument || !mGridVisible)
return;
QPointF offset;
// Take into account the offset of the current layer
if (Layer *layer = mMapDocument->currentLayer()) {
offset = layer->offset();
painter->translate(offset);
}
Preferences *prefs = Preferences::instance();
mMapDocument->renderer()->drawGrid(painter,
rect.translated(-offset),
prefs->gridColor());
}
void KPrViewModePreviewShapeAnimations::paint(KoPACanvasBase *canvas, QPainter &painter, const QRectF &paintRect)
{
#ifdef NDEBUG
Q_UNUSED(canvas);
#else
Q_ASSERT(m_canvas == canvas);
#endif
painter.translate(-m_canvas->documentOffset());
painter.setRenderHint(QPainter::Antialiasing);
QRect clipRect = paintRect.translated(m_canvas->documentOffset()).toRect();
painter.setClipRect(clipRect);
painter.translate(m_canvas->documentOrigin().x(), m_canvas->documentOrigin().y());
KoViewConverter *converter = m_view->viewConverter(m_canvas);
KoShapePaintingContext context;
view()->activePage()->paintBackground(painter, *converter, context);
canvas->shapeManager()->paint(painter, *converter, true);
}
void KisScratchPad::paintEvent ( QPaintEvent * event ) {
if(!m_paintLayer) return;
QRectF imageRect = widgetToDocument().mapRect(QRectF(event->rect()));
QRect alignedImageRect =
imageRect.adjusted(-m_scaleBorderWidth, -m_scaleBorderWidth,
m_scaleBorderWidth, m_scaleBorderWidth).toAlignedRect();
QPointF offset = alignedImageRect.topLeft();
m_paintLayer->updateProjection(alignedImageRect);
KisPaintDeviceSP projection = m_paintLayer->projection();
QImage image = projection->convertToQImage(m_displayProfile,
alignedImageRect.x(),
alignedImageRect.y(),
alignedImageRect.width(),
alignedImageRect.height(),
KoColorConversionTransformation::IntentPerceptual,
KoColorConversionTransformation::BlackpointCompensation);
QPainter gc(this);
gc.fillRect(event->rect(), m_checkBrush);
gc.setRenderHints(QPainter::SmoothPixmapTransform);
gc.drawImage(QRectF(event->rect()), image, imageRect.translated(-offset));
QBrush brush(Qt::lightGray);
QPen pen(brush, 1, Qt::DotLine);
gc.setPen(pen);
if (m_cutoutOverlay.isValid()) {
gc.drawRect(m_cutoutOverlay);
}
if(!isEnabled()) {
QColor color(Qt::lightGray);
color.setAlphaF(0.5);
QBrush disabledBrush(color);
gc.fillRect(event->rect(), disabledBrush);
}
gc.end();
}
static bool intersect_point(const QGraphicsItem *item, const QRectF &exposeRect, Qt::ItemSelectionMode mode,
const QTransform &deviceTransform, const void *intersectData)
{
const QPointF scenePoint = *static_cast<const QPointF *>(intersectData);
QRectF brect = item->boundingRect();
_q_adjustRect(&brect);
// ### Add test for this (without making things slower?)
Q_UNUSED(exposeRect);
bool keep = false;
const QGraphicsItemPrivate *itemd = QGraphicsItemPrivate::get(item);
if (itemd->itemIsUntransformable()) {
// Untransformable items; map the scene point to item coordinates.
const QTransform transform = item->deviceTransform(deviceTransform);
QPointF itemPoint = (deviceTransform * transform.inverted()).map(scenePoint);
keep = brect.contains(itemPoint);
if (keep && (mode == Qt::ContainsItemShape || mode == Qt::IntersectsItemShape)) {
QPainterPath pointPath;
pointPath.addRect(QRectF(itemPoint, QSizeF(1, 1)));
keep = QGraphicsSceneIndexPrivate::itemCollidesWithPath(item, pointPath, mode);
}
} else {
Q_ASSERT(!itemd->dirtySceneTransform);
QRectF sceneBoundingRect = itemd->sceneTransformTranslateOnly
? brect.translated(itemd->sceneTransform.dx(),
itemd->sceneTransform.dy())
: itemd->sceneTransform.mapRect(brect);
keep = sceneBoundingRect.intersects(QRectF(scenePoint, QSizeF(1, 1)));
if (keep && (mode == Qt::ContainsItemShape || mode == Qt::IntersectsItemShape)) {
QPointF p = itemd->sceneTransformTranslateOnly
? QPointF(scenePoint.x() - itemd->sceneTransform.dx(),
scenePoint.y() - itemd->sceneTransform.dy())
: itemd->sceneTransform.inverted().map(scenePoint);
keep = item->contains(p);
}
}
return keep;
}
