qgraphicsitem.cpp File Reference

#include "qgraphicsitem.h"
#include "qgraphicsscene.h"
#include "qgraphicsscene_p.h"
#include "qgraphicssceneevent.h"
#include "qgraphicsview.h"
#include "qgraphicswidget.h"
#include "qgraphicsproxywidget.h"
#include "qgraphicsscenebsptreeindex_p.h"
#include <QtCore/qbitarray.h>
#include <QtCore/qdebug.h>
#include <QtCore/qpoint.h>
#include <QtCore/qstack.h>
#include <QtCore/qtimer.h>
#include <QtCore/qvariant.h>
#include <QtCore/qvarlengtharray.h>
#include <QtCore/qnumeric.h>
#include <QtGui/qapplication.h>
#include <QtGui/qbitmap.h>
#include <QtGui/qpainter.h>
#include <QtGui/qpainterpath.h>
#include <QtGui/qpixmapcache.h>
#include <QtGui/qstyleoption.h>
#include <QtGui/qevent.h>
#include <QtGui/qinputcontext.h>
#include <QtGui/qgraphicseffect.h>
#include "qaccessible.h"
#include <private/qgraphicsitem_p.h>
#include <private/qgraphicswidget_p.h>
#include <private/qtextcontrol_p.h>
#include <private/qtextdocumentlayout_p.h>
#include <private/qtextengine_p.h>
#include <private/qwidget_p.h>
#include <private/qapplication_p.h>
#include <private/qt_x11_p.h>
#include <private/qpixmap_x11_p.h>
#include <private/qgesturemanager_p.h>
#include <math.h>
#include "moc_qgraphicsitem.cpp"

Go to the source code of this file.

Classes
class	QAbstractGraphicsShapeItemPrivate
class	QGraphicsEllipseItemPrivate
class	QGraphicsItemCustomDataStore
class	QGraphicsItemGroupPrivate
class	QGraphicsLineItemPrivate
class	QGraphicsPathItemPrivate
class	QGraphicsPixmapItemPrivate
class	QGraphicsPolygonItemPrivate
class	QGraphicsRectItemPrivate
class	QGraphicsSimpleTextItemPrivate
class	QGraphicsTextItemPrivate

Functions
static void	_q_adjustRect (QRect *rect)
static void	_q_qgraphicsItemSetFlag (QGraphicsItem *item, QGraphicsItem::GraphicsItemFlag flag, bool enabled)
	Sets the flag flag on item and all its children, to enabled. More...
bool	_qt_movableAncestorIsSelected (const QGraphicsItem *item)
	obsolete More...
QDebug	operator<< (QDebug debug, QGraphicsItem *item)
QDebug	operator<< (QDebug debug, QGraphicsObject *item)
QDebug	operator<< (QDebug debug, QGraphicsItem::GraphicsItemChange change)
QDebug	operator<< (QDebug debug, QGraphicsItem::GraphicsItemFlag flag)
QDebug	operator<< (QDebug debug, QGraphicsItem::GraphicsItemFlags flags)
static void	qt_graphicsItem_highlightSelected (QGraphicsItem *item, QPainter *painter, const QStyleOptionGraphicsItem *option)
	Highlights item as selected. More...
static QPainterPath	qt_graphicsItem_shapeFromPath (const QPainterPath &path, const QPen &pen)
	Returns a QPainterPath of path when stroked with the pen. More...
static bool	qt_QGraphicsItem_isObscured (const QGraphicsItem *item, const QGraphicsItem *other, const QRectF &rect)
	Item obscurity helper function. More...
Q_AUTOTEST_EXPORT QPainterPath	qt_regionToPath (const QRegion &region)
static QRectF	setupTextLayout (QTextLayout *layout)

Function Documentation

_q_adjustRect()

static void _q_adjustRect ( QRect *  rect )

inlinestatic

Definition at line 794 of file qgraphicsitem.cpp.

Referenced by QGraphicsItem::boundingRegion(), QGraphicsItem::collidesWithPath(), QGraphicsScenePrivate::drawItemHelper(), QGraphicsSceneIndexRectIntersector::intersect(), QGraphicsSceneIndexPointIntersector::intersect(), QGraphicsSceneIndexPathIntersector::intersect(), QGraphicsSceneIndex::items(), and QGraphicsScenePrivate::processDirtyItemsRecursive().

{
    Q_ASSERT(rect);
    if (!rect->width())
        rect->adjust(0, 0, 1, 0);
    if (!rect->height())
        rect->adjust(0, 0, 0, 1);
}

_q_qgraphicsItemSetFlag()

static void _q_qgraphicsItemSetFlag ( QGraphicsItem *  item, QGraphicsItem::GraphicsItemFlag  flag, bool  enabled  )

static

Sets the flag flag on item and all its children, to enabled.

Warning

This function is not part of the public interface.

Definition at line 1917 of file qgraphicsitem.cpp.

{
    if (item->flags() & flag) {
        // If this item already has the correct flag set, we don't have to
        // propagate it.
        return;
    }
    item->setFlag(flag, enabled);
    foreach (QGraphicsItem *child, item->children())
        _q_qgraphicsItemSetFlag(child, flag, enabled);
}

_qt_movableAncestorIsSelected()

bool _qt_movableAncestorIsSelected

(

const QGraphicsItem *

item

)

obsolete

Definition at line 7523 of file qgraphicsitem.cpp.

Referenced by QGraphicsItemPrivate::movableAncestorIsSelected().

{
    const QGraphicsItem *parent = item->parentItem();
    return parent && (((parent->flags() & QGraphicsItem::ItemIsMovable) && parent->isSelected()) || _qt_movableAncestorIsSelected(parent));
}

operator<<() [1/5]

QDebug operator<<	(	QDebug	debug,
		QGraphicsItem *	item
	)

Definition at line 11946 of file qgraphicsitem.cpp.

Referenced by qgraphicsitem_cast().

{
    if (!item) {
        debug << "QGraphicsItem(0)";
        return debug;
    }

    if (QGraphicsObject *o = item->toGraphicsObject())
        debug << o->metaObject()->className();
    else
        debug << "QGraphicsItem";
    debug << "(this =" << (void*)item
          << ", parent =" << (void*)item->parentItem()
          << ", pos =" << item->pos()
          << ", z =" << item->zValue() << ", flags = "
          << item->flags() << ")";
    return debug;
}

operator<<() [2/5]

QDebug operator<<	(	QDebug	debug,
		QGraphicsObject *	item
	)

Definition at line 11965 of file qgraphicsitem.cpp.

{
    if (!item) {
        debug << "QGraphicsObject(0)";
        return debug;
    }

    debug.nospace() << item->metaObject()->className() << '(' << (void*)item;
    if (!item->objectName().isEmpty())
        debug << ", name = " << item->objectName();
    debug.nospace() << ", parent = " << ((void*)item->parentItem())
          << ", pos = " << item->pos()
          << ", z = " << item->zValue() << ", flags = "
          << item->flags() << ')';
    return debug.space();
}

operator<<() [3/5]

QDebug operator<<	(	QDebug	debug,
		QGraphicsItem::GraphicsItemChange	change
	)

Definition at line 11982 of file qgraphicsitem.cpp.

{
    const char *str = "UnknownChange";
    switch (change) {
    case QGraphicsItem::ItemChildAddedChange:
        str = "ItemChildAddedChange";
        break;
    case QGraphicsItem::ItemChildRemovedChange:
        str = "ItemChildRemovedChange";
        break;
    case QGraphicsItem::ItemCursorChange:
        str = "ItemCursorChange";
        break;
    case QGraphicsItem::ItemCursorHasChanged:
        str = "ItemCursorHasChanged";
        break;
    case QGraphicsItem::ItemEnabledChange:
        str = "ItemEnabledChange";
        break;
    case QGraphicsItem::ItemEnabledHasChanged:
        str = "ItemEnabledHasChanged";
        break;
    case QGraphicsItem::ItemFlagsChange:
        str = "ItemFlagsChange";
        break;
    case QGraphicsItem::ItemFlagsHaveChanged:
        str = "ItemFlagsHaveChanged";
        break;
    case QGraphicsItem::ItemMatrixChange:
        str = "ItemMatrixChange";
        break;
    case QGraphicsItem::ItemParentChange:
        str = "ItemParentChange";
        break;
    case QGraphicsItem::ItemParentHasChanged:
        str = "ItemParentHasChanged";
        break;
    case QGraphicsItem::ItemPositionChange:
        str = "ItemPositionChange";
        break;
    case QGraphicsItem::ItemPositionHasChanged:
        str = "ItemPositionHasChanged";
        break;
    case QGraphicsItem::ItemSceneChange:
        str = "ItemSceneChange";
        break;
    case QGraphicsItem::ItemSceneHasChanged:
        str = "ItemSceneHasChanged";
        break;
    case QGraphicsItem::ItemSelectedChange:
        str = "ItemSelectedChange";
        break;
    case QGraphicsItem::ItemSelectedHasChanged:
        str = "ItemSelectedHasChanged";
        break;
    case QGraphicsItem::ItemToolTipChange:
        str = "ItemToolTipChange";
        break;
    case QGraphicsItem::ItemToolTipHasChanged:
        str = "ItemToolTipHasChanged";
        break;
    case QGraphicsItem::ItemTransformChange:
        str = "ItemTransformChange";
        break;
    case QGraphicsItem::ItemTransformHasChanged:
        str = "ItemTransformHasChanged";
        break;
    case QGraphicsItem::ItemVisibleChange:
        str = "ItemVisibleChange";
        break;
    case QGraphicsItem::ItemVisibleHasChanged:
        str = "ItemVisibleHasChanged";
        break;
    case QGraphicsItem::ItemZValueChange:
        str = "ItemZValueChange";
        break;
    case QGraphicsItem::ItemZValueHasChanged:
        str = "ItemZValueHasChanged";
        break;
    case QGraphicsItem::ItemOpacityChange:
        str = "ItemOpacityChange";
        break;
    case QGraphicsItem::ItemOpacityHasChanged:
        str = "ItemOpacityHasChanged";
        break;
    case QGraphicsItem::ItemScenePositionHasChanged:
        str = "ItemScenePositionHasChanged";
        break;
    case QGraphicsItem::ItemRotationChange:
        str = "ItemRotationChange";
        break;
    case QGraphicsItem::ItemRotationHasChanged:
        str = "ItemRotationHasChanged";
        break;
    case QGraphicsItem::ItemScaleChange:
        str = "ItemScaleChange";
        break;
    case QGraphicsItem::ItemScaleHasChanged:
        str = "ItemScaleHasChanged";
        break;
    case QGraphicsItem::ItemTransformOriginPointChange:
        str = "ItemTransformOriginPointChange";
        break;
    case QGraphicsItem::ItemTransformOriginPointHasChanged:
        str = "ItemTransformOriginPointHasChanged";
        break;
    }
    debug << str;
    return debug;
}

operator<<() [4/5]

QDebug operator<<	(	QDebug	debug,
		QGraphicsItem::GraphicsItemFlag	flag
	)

Definition at line 12093 of file qgraphicsitem.cpp.

{
    const char *str = "UnknownFlag";
    switch (flag) {
    case QGraphicsItem::ItemIsMovable:
        str = "ItemIsMovable";
        break;
    case QGraphicsItem::ItemIsSelectable:
        str = "ItemIsSelectable";
        break;
    case QGraphicsItem::ItemIsFocusable:
        str = "ItemIsFocusable";
        break;
    case QGraphicsItem::ItemClipsToShape:
        str = "ItemClipsToShape";
        break;
    case QGraphicsItem::ItemClipsChildrenToShape:
        str = "ItemClipsChildrenToShape";
        break;
    case QGraphicsItem::ItemIgnoresTransformations:
        str = "ItemIgnoresTransformations";
        break;
    case QGraphicsItem::ItemIgnoresParentOpacity:
        str = "ItemIgnoresParentOpacity";
        break;
    case QGraphicsItem::ItemDoesntPropagateOpacityToChildren:
        str = "ItemDoesntPropagateOpacityToChildren";
        break;
    case QGraphicsItem::ItemStacksBehindParent:
        str = "ItemStacksBehindParent";
        break;
    case QGraphicsItem::ItemUsesExtendedStyleOption:
        str = "ItemUsesExtendedStyleOption";
        break;
    case QGraphicsItem::ItemHasNoContents:
        str = "ItemHasNoContents";
        break;
    case QGraphicsItem::ItemSendsGeometryChanges:
        str = "ItemSendsGeometryChanges";
        break;
    case QGraphicsItem::ItemAcceptsInputMethod:
        str = "ItemAcceptsInputMethod";
        break;
    case QGraphicsItem::ItemNegativeZStacksBehindParent:
        str = "ItemNegativeZStacksBehindParent";
        break;
    case QGraphicsItem::ItemIsPanel:
        str = "ItemIsPanel";
        break;
    case QGraphicsItem::ItemIsFocusScope:
        str = "ItemIsFocusScope";
        break;
    case QGraphicsItem::ItemSendsScenePositionChanges:
        str = "ItemSendsScenePositionChanges";
        break;
    case QGraphicsItem::ItemStopsClickFocusPropagation:
        str = "ItemStopsClickFocusPropagation";
        break;
    case QGraphicsItem::ItemStopsFocusHandling:
        str = "ItemStopsFocusHandling";
        break;
    }
    debug << str;
    return debug;
}

operator<<() [5/5]

QDebug operator<<	(	QDebug	debug,
		QGraphicsItem::GraphicsItemFlags	flags
	)

Definition at line 12159 of file qgraphicsitem.cpp.

{
    debug << '(';
    bool f = false;
    for (int i = 0; i < 17; ++i) {
        if (flags & (1 << i)) {
            if (f)
                debug << '|';
            f = true;
            debug << QGraphicsItem::GraphicsItemFlag(int(flags & (1 << i)));
        }
    }
    debug << ')';
    return debug;
}

qt_graphicsItem_highlightSelected()

static void qt_graphicsItem_highlightSelected ( QGraphicsItem *  item, QPainter *  painter, const QStyleOptionGraphicsItem *  option  )

static

Highlights item as selected.

Warning

This function is not part of the public interface.

NOTE: This function is a duplicate of qt_graphicsItem_highlightSelected() in qgraphicssvgitem.cpp!

Definition at line 8024 of file qgraphicsitem.cpp.

Referenced by QGraphicsPathItem::paint(), QGraphicsRectItem::paint(), QGraphicsEllipseItem::paint(), QGraphicsPolygonItem::paint(), QGraphicsLineItem::paint(), QGraphicsPixmapItem::paint(), QGraphicsTextItem::paint(), and QGraphicsSimpleTextItem::paint().

{
    const QRectF murect = painter->transform().mapRect(QRectF(0, 0, 1, 1));
    if (qFuzzyIsNull(qMax(murect.width(), murect.height())))
        return;

    const QRectF mbrect = painter->transform().mapRect(item->boundingRect());
    if (qMin(mbrect.width(), mbrect.height()) < qreal(1.0))
        return;

    qreal itemPenWidth;
    switch (item->type()) {
        case QGraphicsEllipseItem::Type:
            itemPenWidth = static_cast<QGraphicsEllipseItem *>(item)->pen().widthF();
            break;
        case QGraphicsPathItem::Type:
            itemPenWidth = static_cast<QGraphicsPathItem *>(item)->pen().widthF();
            break;
        case QGraphicsPolygonItem::Type:
            itemPenWidth = static_cast<QGraphicsPolygonItem *>(item)->pen().widthF();
            break;
        case QGraphicsRectItem::Type:
            itemPenWidth = static_cast<QGraphicsRectItem *>(item)->pen().widthF();
            break;
        case QGraphicsSimpleTextItem::Type:
            itemPenWidth = static_cast<QGraphicsSimpleTextItem *>(item)->pen().widthF();
            break;
        case QGraphicsLineItem::Type:
            itemPenWidth = static_cast<QGraphicsLineItem *>(item)->pen().widthF();
            break;
        default:
            itemPenWidth = 1.0;
    }
    const qreal pad = itemPenWidth / 2;

    const qreal penWidth = 0; // cosmetic pen

    const QColor fgcolor = option->palette.windowText().color();
    const QColor bgcolor( // ensure good contrast against fgcolor
        fgcolor.red()   > 127 ? 0 : 255,
        fgcolor.green() > 127 ? 0 : 255,
        fgcolor.blue()  > 127 ? 0 : 255);

    painter->setPen(QPen(bgcolor, penWidth, Qt::SolidLine));
    painter->setBrush(Qt::NoBrush);
    painter->drawRect(item->boundingRect().adjusted(pad, pad, -pad, -pad));

    painter->setPen(QPen(option->palette.windowText(), 0, Qt::DashLine));
    painter->setBrush(Qt::NoBrush);
    painter->drawRect(item->boundingRect().adjusted(pad, pad, -pad, -pad));
}

qt_graphicsItem_shapeFromPath()

static QPainterPath qt_graphicsItem_shapeFromPath ( const QPainterPath &  path, const QPen &  pen  )

static

Returns a QPainterPath of path when stroked with the pen.

Warning

This function is not part of the public interface.

Ignoring dash pattern.

Definition at line 822 of file qgraphicsitem.cpp.

Referenced by QGraphicsPathItem::shape(), QGraphicsRectItem::shape(), QGraphicsEllipseItem::shape(), QGraphicsPolygonItem::shape(), and QGraphicsLineItem::shape().

{
    // We unfortunately need this hack as QPainterPathStroker will set a width of 1.0
    // if we pass a value of 0.0 to QPainterPathStroker::setWidth()
    const qreal penWidthZero = qreal(0.00000001);

    if (path == QPainterPath())
        return path;
    QPainterPathStroker ps;
    ps.setCapStyle(pen.capStyle());
    if (pen.widthF() <= 0.0)
        ps.setWidth(penWidthZero);
    else
        ps.setWidth(pen.widthF());
    ps.setJoinStyle(pen.joinStyle());
    ps.setMiterLimit(pen.miterLimit());
    QPainterPath p = ps.createStroke(path);
    p.addPath(path);
    return p;
}

qt_QGraphicsItem_isObscured()

static bool qt_QGraphicsItem_isObscured ( const QGraphicsItem *  item, const QGraphicsItem *  other, const QRectF &  rect  )

static

Item obscurity helper function.

Warning

This function is not part of the public interface.

Returns true if the subrect rect of item's bounding rect is obscured by other (i.e., other's opaque area covers item's rect completely. other is assumed to already be "on top of" item wrt. stacking order.

Definition at line 5430 of file qgraphicsitem.cpp.

Referenced by QGraphicsItem::isObscured(), and QGraphicsItem::isObscuredBy().

{
    return other->mapToItem(item, other->opaqueArea()).contains(rect);
}

qt_regionToPath()

Q_AUTOTEST_EXPORT QPainterPath qt_regionToPath

(

const QRegion &

region

)

Definition at line 1160 of file qregion.cpp.

Referenced by QGraphicsLineItem::extension(), QGraphicsPixmapItemPrivate::updateShape(), and QX11PaintEngine::updateState().

{
    QPainterPath result;
    if (region.rectCount() == 1) {
        result.addRect(region.boundingRect());
        return result;
    }

    const QVector<QRect> rects = region.rects();

    QVarLengthArray<Segment> segments;
    segments.resize(4 * rects.size());

    const QRect *rect = rects.constData();
    const QRect *end = rect + rects.size();

    int lastRowSegmentCount = 0;
    Segment *lastRowSegments = 0;

    int lastSegment = 0;
    int lastY = 0;
    while (rect != end) {
        const int y = rect[0].y();
        int count = 0;
        while (&rect[count] != end && rect[count].y() == y)
            ++count;

        for (int i = 0; i < count; ++i) {
            int offset = lastSegment + i;
            segments[offset] = Segment(rect[i].topLeft());
            segments[offset += count] = Segment(rect[i].topRight() + QPoint(1, 0));
            segments[offset += count] = Segment(rect[i].bottomRight() + QPoint(1, 1));
            segments[offset += count] = Segment(rect[i].bottomLeft() + QPoint(0, 1));

            offset = lastSegment + i;
            for (int j = 0; j < 4; ++j)
                segments[offset + j * count].connect(segments[offset + ((j + 1) % 4) * count]);
        }

        if (lastRowSegments && lastY == y)
            mergeSegments(lastRowSegments, lastRowSegmentCount, &segments[lastSegment], count);

        lastRowSegments = &segments[lastSegment + 2 * count];
        lastRowSegmentCount = count;
        lastSegment += 4 * count;
        lastY = y + rect[0].height();
        rect += count;
    }

    for (int i = 0; i < lastSegment; ++i) {
        Segment *segment = &segments[i];
        if (!segment->added)
            addSegmentsToPath(segment, result);
    }

    return result;
}

setupTextLayout()

static QRectF setupTextLayout ( QTextLayout *  layout )

static

Definition at line 11269 of file qgraphicsitem.cpp.

Referenced by QGraphicsSimpleTextItem::paint(), QGraphicsSimpleTextItemPrivate::updateBoundingRect(), and QDeclarativeTextPrivate::updateSize().

{
    layout->setCacheEnabled(true);
    layout->beginLayout();
    while (layout->createLine().isValid())
        ;
    layout->endLayout();
    qreal maxWidth = 0;
    qreal y = 0;
    for (int i = 0; i < layout->lineCount(); ++i) {
        QTextLine line = layout->lineAt(i);
        maxWidth = qMax(maxWidth, line.naturalTextWidth());
        line.setPosition(QPointF(0, y));
        y += line.height();
    }
    return QRectF(0, 0, maxWidth, y);
}