qgraphicsscene.cpp File Reference

#include "qgraphicsscene.h"
#include "qgraphicsitem.h"
#include "qgraphicsitem_p.h"
#include "qgraphicslayout.h"
#include "qgraphicsscene_p.h"
#include "qgraphicssceneevent.h"
#include "qgraphicsview.h"
#include "qgraphicsview_p.h"
#include "qgraphicswidget.h"
#include "qgraphicswidget_p.h"
#include "qgraphicssceneindex_p.h"
#include "qgraphicsscenebsptreeindex_p.h"
#include "qgraphicsscenelinearindex_p.h"
#include <QtCore/qdebug.h>
#include <QtCore/qlist.h>
#include <QtCore/qmath.h>
#include <QtCore/qrect.h>
#include <QtCore/qset.h>
#include <QtCore/qstack.h>
#include <QtCore/qtimer.h>
#include <QtCore/qvarlengtharray.h>
#include <QtCore/QMetaMethod>
#include <QtGui/qapplication.h>
#include <QtGui/qdesktopwidget.h>
#include <QtGui/qevent.h>
#include <QtGui/qgraphicslayout.h>
#include <QtGui/qgraphicsproxywidget.h>
#include <QtGui/qgraphicswidget.h>
#include <QtGui/qmatrix.h>
#include <QtGui/qpaintengine.h>
#include <QtGui/qpainter.h>
#include <QtGui/qpixmapcache.h>
#include <QtGui/qpolygon.h>
#include <QtGui/qstyleoption.h>
#include <QtGui/qtooltip.h>
#include <QtGui/qtransform.h>
#include <QtGui/qinputcontext.h>
#include <QtGui/qgraphicseffect.h>
#include <QtGui/qaccessible.h>
#include <private/qapplication_p.h>
#include <private/qobject_p.h>
#include <private/qt_x11_p.h>
#include <private/qgraphicseffect_p.h>
#include <private/qgesturemanager_p.h>
#include <private/qpathclipper_p.h>
#include "moc_qgraphicsscene.cpp"

Go to the source code of this file.

Macros
#define	ENSURE_TRANSFORM_PTR
#define	G_DEBUG   if (0) qDebug

Functions
static void	_q_hoverFromMouseEvent (QGraphicsSceneHoverEvent *hover, const QGraphicsSceneMouseEvent *mouseEvent)
static void	_q_paintIntoCache (QPixmap *pix, QGraphicsItem *item, const QRegion &pixmapExposed, const QTransform &itemToPixmap, QPainter::RenderHints renderHints, const QStyleOptionGraphicsItem *option, bool painterStateProtection)
static void	_q_paintItem (QGraphicsItem *item, QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget, bool useWindowOpacity, bool painterStateProtection)
bool	qt_sendSpontaneousEvent (QObject *receiver, QEvent *event)
static void	setClip (QPainter *painter, QGraphicsItem *item)
static void	setWorldTransform (QPainter *painter, const QTransform *const transformPtr, const QTransform *effectTransform)
static bool	transformIsSimple (const QTransform &transform)
static bool	updateHelper (QGraphicsViewPrivate *view, QGraphicsItemPrivate *item, const QRectF &rect, bool itemIsUntransformable)

Macro Definition Documentation

ENSURE_TRANSFORM_PTR

#define ENSURE_TRANSFORM_PTR

Value:

if (!transformPtr) { \
        Q_ASSERT(!itemIsUntransformable); \
        if (viewTransform) { \
            transform = item->d_ptr->sceneTransform; \
            transform *= *viewTransform; \
            transformPtr = &transform; \
        } else { \
            transformPtr = &item->d_ptr->sceneTransform; \
            translateOnlyTransform = item->d_ptr->sceneTransformTranslateOnly; \
        } \
    }

Referenced by QGraphicsScenePrivate::drawSubtreeRecursive().

G_DEBUG

#define G_DEBUG   if (0) qDebug

Definition at line 271 of file qgraphicsscene.cpp.

Referenced by QGraphicsScenePrivate::cancelGesturesForChildren(), and QGraphicsScenePrivate::gestureEventHandler().

Function Documentation

_q_hoverFromMouseEvent()

static void _q_hoverFromMouseEvent ( QGraphicsSceneHoverEvent *  hover, const QGraphicsSceneMouseEvent *  mouseEvent  )

static

Definition at line 280 of file qgraphicsscene.cpp.

Referenced by QGraphicsScene::mouseMoveEvent(), QGraphicsScene::mousePressEvent(), and QGraphicsScene::mouseReleaseEvent().

{
    hover->setWidget(mouseEvent->widget());
    hover->setPos(mouseEvent->pos());
    hover->setScenePos(mouseEvent->scenePos());
    hover->setScreenPos(mouseEvent->screenPos());
    hover->setLastPos(mouseEvent->lastPos());
    hover->setLastScenePos(mouseEvent->lastScenePos());
    hover->setLastScreenPos(mouseEvent->lastScreenPos());
    hover->setModifiers(mouseEvent->modifiers());
    hover->setAccepted(mouseEvent->isAccepted());
}

_q_paintIntoCache()

static void _q_paintIntoCache ( QPixmap *  pix, QGraphicsItem *  item, const QRegion &  pixmapExposed, const QTransform &  itemToPixmap, QPainter::RenderHints  renderHints, const QStyleOptionGraphicsItem *  option, bool  painterStateProtection  )

static

Definition at line 4466 of file qgraphicsscene.cpp.

Referenced by QGraphicsScenePrivate::drawItemHelper().

{
    QPixmap subPix;
    QPainter pixmapPainter;
    QRect br = pixmapExposed.boundingRect();

    // Don't use subpixmap if we get a full update.
    if (pixmapExposed.isEmpty() || (pixmapExposed.rectCount() == 1 && br.contains(pix->rect()))) {
        pix->fill(Qt::transparent);
        pixmapPainter.begin(pix);
    } else {
        subPix = QPixmap(br.size());
        subPix.fill(Qt::transparent);
        pixmapPainter.begin(&subPix);
        pixmapPainter.translate(-br.topLeft());
        if (!pixmapExposed.isEmpty()) {
            // Applied to subPix; paint is adjusted to the coordinate space is
            // correct.
            pixmapPainter.setClipRegion(pixmapExposed);
        }
    }

    pixmapPainter.setRenderHints(pixmapPainter.renderHints(), false);
    pixmapPainter.setRenderHints(renderHints, true);
    pixmapPainter.setWorldTransform(itemToPixmap, true);

    // Render.
    _q_paintItem(item, &pixmapPainter, option, 0, false, painterStateProtection);
    pixmapPainter.end();

    if (!subPix.isNull()) {
        // Blit the subpixmap into the main pixmap.
        pixmapPainter.begin(pix);
        pixmapPainter.setCompositionMode(QPainter::CompositionMode_Source);
        pixmapPainter.setClipRegion(pixmapExposed);
        pixmapPainter.drawPixmap(br.topLeft(), subPix);
        pixmapPainter.end();
    }
}

_q_paintItem()

static void _q_paintItem ( QGraphicsItem *  item, QPainter *  painter, const QStyleOptionGraphicsItem *  option, QWidget *  widget, bool  useWindowOpacity, bool  painterStateProtection  )

static

Definition at line 4422 of file qgraphicsscene.cpp.

Referenced by _q_paintIntoCache(), and QGraphicsScenePrivate::drawItemHelper().

{
    if (!item->isWidget()) {
        item->paint(painter, option, widget);
        return;
    }
    QGraphicsWidget *widgetItem = static_cast<QGraphicsWidget *>(item);
    QGraphicsProxyWidget *proxy = qobject_cast<QGraphicsProxyWidget *>(widgetItem);
    const qreal windowOpacity = (proxy && proxy->widget() && useWindowOpacity)
                                ? proxy->widget()->windowOpacity() : qreal(1.0);
    const qreal oldPainterOpacity = painter->opacity();

    if (qFuzzyIsNull(windowOpacity))
        return;
    // Set new painter opacity.
    if (windowOpacity < 1.0)
        painter->setOpacity(oldPainterOpacity * windowOpacity);

    // set layoutdirection on the painter
    Qt::LayoutDirection oldLayoutDirection = painter->layoutDirection();
    painter->setLayoutDirection(widgetItem->layoutDirection());

    if (widgetItem->isWindow() && widgetItem->windowType() != Qt::Popup && widgetItem->windowType() != Qt::ToolTip
        && !(widgetItem->windowFlags() & Qt::FramelessWindowHint)) {
        if (painterStateProtection)
            painter->save();
        widgetItem->paintWindowFrame(painter, option, widget);
        if (painterStateProtection)
            painter->restore();
    } else if (widgetItem->autoFillBackground()) {
        painter->fillRect(option->exposedRect, widgetItem->palette().window());
    }

    widgetItem->paint(painter, option, widget);

    // Restore layoutdirection on the painter.
    painter->setLayoutDirection(oldLayoutDirection);
    // Restore painter opacity.
    if (windowOpacity < 1.0)
        painter->setOpacity(oldPainterOpacity);
}

qt_sendSpontaneousEvent()

bool qt_sendSpontaneousEvent	(	QObject *	receiver,
		QEvent *	event
	)

Definition at line 5779 of file qapplication.cpp.

Referenced by QGraphicsScenePrivate::sendEvent().

{
    return QCoreApplication::sendSpontaneousEvent(receiver, event);
}

setClip()

static void setClip ( QPainter *  painter, QGraphicsItem *  item  )

inlinestatic

Definition at line 4986 of file qgraphicsscene.cpp.

Referenced by QGraphicsScenePrivate::draw().

{
    painter->save();
    QRectF clipRect;
    const QPainterPath clipPath(item->shape());
    if (QPathClipper::pathToRect(clipPath, &clipRect))
        painter->setClipRect(clipRect, Qt::IntersectClip);
    else
        painter->setClipPath(clipPath, Qt::IntersectClip);
}

setWorldTransform()

static void setWorldTransform ( QPainter *  painter, const QTransform *const  transformPtr, const QTransform *  effectTransform  )

inlinestatic

Definition at line 4997 of file qgraphicsscene.cpp.

Referenced by QGraphicsScenePrivate::draw(), and QPainter::setTransform().

{
    Q_ASSERT(transformPtr);
    if (effectTransform)
        painter->setWorldTransform(*transformPtr * *effectTransform);
    else
        painter->setWorldTransform(*transformPtr);
}

transformIsSimple()

static bool transformIsSimple ( const QTransform &  transform )

inlinestatic

Definition at line 4510 of file qgraphicsscene.cpp.

Referenced by QGraphicsScenePrivate::drawItemHelper().

{
    QTransform::TransformationType type = transform.type();
    if (type <= QTransform::TxScale) {
        return true;
    } else if (type == QTransform::TxRotate) {
        // Check for 90, and 270 degree rotations.
        qreal m11 = transform.m11();
        qreal m12 = transform.m12();
        qreal m21 = transform.m21();
        qreal m22 = transform.m22();
        if (m11 == 0.0f && m22 == 0.0f) {
            if (m12 == 1.0f && m21 == -1.0f)
                return true; // 90 degrees.
            else if (m12 == -1.0f && m21 == 1.0f)
                return true; // 270 degrees.
            else if (m12 == -1.0f && m21 == -1.0f)
                return true; // 90 degrees inverted y.
            else if (m12 == 1.0f && m21 == 1.0f)
                return true; // 270 degrees inverted y.
        }
    }
    return false;
}

updateHelper()

static bool updateHelper ( QGraphicsViewPrivate *  view, QGraphicsItemPrivate *  item, const QRectF &  rect, bool  itemIsUntransformable  )

inlinestatic

Definition at line 5228 of file qgraphicsscene.cpp.

Referenced by QGraphicsScenePrivate::processDirtyItemsRecursive().

{
    Q_ASSERT(view);
    Q_ASSERT(item);

    QGraphicsItem *itemq = static_cast<QGraphicsItem *>(item->q_ptr);
    QGraphicsView *viewq = static_cast<QGraphicsView *>(view->q_ptr);

    if (itemIsUntransformable) {
        const QTransform xform = itemq->deviceTransform(viewq->viewportTransform());
        if (!item->hasBoundingRegionGranularity)
            return view->updateRectF(xform.mapRect(rect));
        return view->updateRegion(rect, xform);
    }

    if (item->sceneTransformTranslateOnly && view->identityMatrix) {
        const qreal dx = item->sceneTransform.dx();
        const qreal dy = item->sceneTransform.dy();
        QRectF r(rect);
        r.translate(dx - view->horizontalScroll(), dy - view->verticalScroll());
        return view->updateRectF(r);
    }

    if (!viewq->isTransformed()) {
        if (!item->hasBoundingRegionGranularity)
            return view->updateRectF(item->sceneTransform.mapRect(rect));
        return view->updateRegion(rect, item->sceneTransform);
    }

    QTransform xform = item->sceneTransform;
    xform *= viewq->viewportTransform();
    if (!item->hasBoundingRegionGranularity)
        return view->updateRectF(xform.mapRect(rect));
    return view->updateRegion(rect, xform);
}