QQuickItemPrivate::get(referencedItem)->refFromEffectItem(hide);
QQuickCanvasPrivate::get(referencedItem->canvas())->updateDirtyNode(referencedItem);
- Q_ASSERT(QQuickItemPrivate::get(referencedItem)->rootNode);
+ Q_ASSERT(QQuickItemPrivate::get(referencedItem)->rootNode());
if (!m_itemTextureHash.contains(referencedItem)) {
QQuickShaderEffectTexture *texture = new QQuickShaderEffectTexture(referencedItem);
texture->setLive(true);
- texture->setItem(QQuickItemPrivate::get(referencedItem)->rootNode);
+ texture->setItem(QQuickItemPrivate::get(referencedItem)->rootNode());
texture->setRect(referencedItem->boundingRect());
texture->setSize(referencedItem->boundingRect().size().toSize());
texture->setRecursive(true);
class QQuickAnchorLine
{
public:
- QQuickAnchorLine() : item(0), anchorLine(Invalid) {}
-
enum AnchorLine {
Invalid = 0x0,
Left = 0x01,
Vertical_Mask = Top | Bottom | VCenter | Baseline
};
+ QQuickAnchorLine() : item(0), anchorLine(Invalid) {}
+ QQuickAnchorLine(QQuickItem *i, AnchorLine l) : item(i), anchorLine(l) {}
+
QQuickItem *item;
AnchorLine anchorLine;
};
Q_Q(QQuickCanvas);
QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
- if (itemPrivate->opacity == 0.0)
+ if (itemPrivate->opacity() == 0.0)
return false;
if (itemPrivate->flags & QQuickItem::ItemClipsChildrenToShape) {
return true;
}
- if (itemPrivate->acceptedMouseButtons & event->button()) {
+ if (itemPrivate->acceptedMouseButtons() & event->button()) {
QPointF p = item->mapFromScene(event->windowPos());
if (QRectF(0, 0, item->width(), item->height()).contains(p)) {
QMouseEvent me(event->type(), p, event->windowPos(), event->screenPos(),
Qt::KeyboardModifiers modifiers, bool &accepted)
{
QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
- if (itemPrivate->opacity == 0.0)
+ if (itemPrivate->opacity() == 0.0)
return false;
if (itemPrivate->flags & QQuickItem::ItemClipsChildrenToShape) {
{
Q_Q(QQuickCanvas);
QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
- if (itemPrivate->opacity == 0.0)
+ if (itemPrivate->opacity() == 0.0)
return false;
if (itemPrivate->flags & QQuickItem::ItemClipsChildrenToShape) {
Q_Q(QQuickCanvas);
QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
- if (itemPrivate->opacity == 0.0)
+ if (itemPrivate->opacity() == 0.0)
return false;
if (itemPrivate->flags & QQuickItem::ItemClipsChildrenToShape) {
Q_Q(QQuickCanvas);
bool accepted = false;
QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
- if (itemPrivate->opacity == 0.0 || !item->isVisible() || !item->isEnabled())
+ if (itemPrivate->opacity() == 0.0 || !item->isVisible() || !item->isEnabled())
return false;
QPointF p = item->mapFromScene(event->pos());
if (p->itemNodeInstance) {
delete p->itemNodeInstance;
p->itemNodeInstance = 0;
- p->opacityNode = 0;
- p->clipNode = 0;
+
+ if (p->extra.isAllocated()) {
+ p->extra->opacityNode = 0;
+ p->extra->clipNode = 0;
+ }
+
p->groupNode = 0;
p->paintNode = 0;
}
itemPriv->dirtyAttributes = 0;
if ((dirty & QQuickItemPrivate::TransformUpdateMask) ||
- (dirty & QQuickItemPrivate::Size && itemPriv->origin != QQuickItem::TopLeft &&
- (itemPriv->scale != 1. || itemPriv->rotation != 0.))) {
+ (dirty & QQuickItemPrivate::Size && itemPriv->origin() != QQuickItem::TopLeft &&
+ (itemPriv->scale() != 1. || itemPriv->rotation() != 0.))) {
QMatrix4x4 matrix;
for (int ii = itemPriv->transforms.count() - 1; ii >= 0; --ii)
itemPriv->transforms.at(ii)->applyTo(&matrix);
- if (itemPriv->scale != 1. || itemPriv->rotation != 0.) {
+ if (itemPriv->scale() != 1. || itemPriv->rotation() != 0.) {
QPointF origin = item->transformOriginPoint();
matrix.translate(origin.x(), origin.y());
- if (itemPriv->scale != 1.)
- matrix.scale(itemPriv->scale, itemPriv->scale);
- if (itemPriv->rotation != 0.)
- matrix.rotate(itemPriv->rotation, 0, 0, 1);
+ if (itemPriv->scale() != 1.)
+ matrix.scale(itemPriv->scale(), itemPriv->scale());
+ if (itemPriv->rotation() != 0.)
+ matrix.rotate(itemPriv->rotation(), 0, 0, 1);
matrix.translate(-origin.x(), -origin.y());
}
}
bool clipEffectivelyChanged = (dirty & (QQuickItemPrivate::Clip | QQuickItemPrivate::Canvas)) &&
- ((item->clip() == false) != (itemPriv->clipNode == 0));
+ ((item->clip() == false) != (itemPriv->clipNode() == 0));
+ int effectRefCount = itemPriv->extra.isAllocated()?itemPriv->extra->effectRefCount:0;
bool effectRefEffectivelyChanged = (dirty & (QQuickItemPrivate::EffectReference | QQuickItemPrivate::Canvas)) &&
- ((itemPriv->effectRefCount == 0) != (itemPriv->rootNode == 0));
+ ((effectRefCount == 0) != (itemPriv->rootNode() == 0));
if (clipEffectivelyChanged) {
- QSGNode *parent = itemPriv->opacityNode ? (QSGNode *) itemPriv->opacityNode : (QSGNode *)itemPriv->itemNode();
- QSGNode *child = itemPriv->rootNode ? (QSGNode *)itemPriv->rootNode : (QSGNode *)itemPriv->groupNode;
+ QSGNode *parent = itemPriv->opacityNode() ? (QSGNode *) itemPriv->opacityNode() :
+ (QSGNode *)itemPriv->itemNode();
+ QSGNode *child = itemPriv->rootNode() ? (QSGNode *)itemPriv->rootNode() :
+ (QSGNode *)itemPriv->groupNode;
if (item->clip()) {
- Q_ASSERT(itemPriv->clipNode == 0);
- itemPriv->clipNode = new QQuickDefaultClipNode(item->boundingRect());
- itemPriv->clipNode->update();
+ Q_ASSERT(itemPriv->clipNode() == 0);
+ itemPriv->extra.value().clipNode = new QQuickDefaultClipNode(item->boundingRect());
+ itemPriv->clipNode()->update();
if (child)
parent->removeChildNode(child);
- parent->appendChildNode(itemPriv->clipNode);
+ parent->appendChildNode(itemPriv->clipNode());
if (child)
- itemPriv->clipNode->appendChildNode(child);
+ itemPriv->clipNode()->appendChildNode(child);
} else {
- Q_ASSERT(itemPriv->clipNode != 0);
- parent->removeChildNode(itemPriv->clipNode);
+ Q_ASSERT(itemPriv->clipNode() != 0);
+ parent->removeChildNode(itemPriv->clipNode());
if (child)
- itemPriv->clipNode->removeChildNode(child);
- delete itemPriv->clipNode;
- itemPriv->clipNode = 0;
+ itemPriv->clipNode()->removeChildNode(child);
+ delete itemPriv->clipNode();
+ itemPriv->extra->clipNode = 0;
if (child)
parent->appendChildNode(child);
}
itemPriv->childContainerNode()->removeAllChildNodes();
if (effectRefEffectivelyChanged) {
- QSGNode *parent = itemPriv->clipNode;
+ QSGNode *parent = itemPriv->clipNode();
if (!parent)
- parent = itemPriv->opacityNode;
+ parent = itemPriv->opacityNode();
if (!parent)
parent = itemPriv->itemNode();
QSGNode *child = itemPriv->groupNode;
- if (itemPriv->effectRefCount) {
- Q_ASSERT(itemPriv->rootNode == 0);
- itemPriv->rootNode = new QSGRootNode;
+ if (itemPriv->extra.isAllocated() && itemPriv->extra->effectRefCount) {
+ Q_ASSERT(itemPriv->rootNode() == 0);
+ itemPriv->extra->rootNode = new QSGRootNode;
if (child)
parent->removeChildNode(child);
- parent->appendChildNode(itemPriv->rootNode);
+ parent->appendChildNode(itemPriv->rootNode());
if (child)
- itemPriv->rootNode->appendChildNode(child);
+ itemPriv->rootNode()->appendChildNode(child);
} else {
- Q_ASSERT(itemPriv->rootNode != 0);
- parent->removeChildNode(itemPriv->rootNode);
+ Q_ASSERT(itemPriv->rootNode() != 0);
+ parent->removeChildNode(itemPriv->rootNode());
if (child)
- itemPriv->rootNode->removeChildNode(child);
- delete itemPriv->rootNode;
- itemPriv->rootNode = 0;
+ itemPriv->rootNode()->removeChildNode(child);
+ delete itemPriv->rootNode();
+ itemPriv->extra->rootNode = 0;
if (child)
parent->appendChildNode(child);
}
for (; ii < orderedChildren.count() && orderedChildren.at(ii)->z() < 0; ++ii) {
QQuickItemPrivate *childPrivate = QQuickItemPrivate::get(orderedChildren.at(ii));
- if (!childPrivate->explicitVisible && !childPrivate->effectRefCount)
+ if (!childPrivate->explicitVisible &&
+ (!childPrivate->extra.isAllocated() || !childPrivate->extra->effectRefCount))
continue;
if (childPrivate->itemNode()->parent())
childPrivate->itemNode()->parent()->removeChildNode(childPrivate->itemNode());
itemPriv->childContainerNode()->appendChildNode(childPrivate->itemNode());
}
- itemPriv->beforePaintNode = itemPriv->groupNode ? itemPriv->groupNode->lastChild() : 0;
+
+ QSGNode *beforePaintNode = itemPriv->groupNode ? itemPriv->groupNode->lastChild() : 0;
+ if (beforePaintNode || itemPriv->extra.isAllocated())
+ itemPriv->extra.value().beforePaintNode = beforePaintNode;
if (itemPriv->paintNode)
itemPriv->childContainerNode()->appendChildNode(itemPriv->paintNode);
for (; ii < orderedChildren.count(); ++ii) {
QQuickItemPrivate *childPrivate = QQuickItemPrivate::get(orderedChildren.at(ii));
- if (!childPrivate->explicitVisible && !childPrivate->effectRefCount)
+ if (!childPrivate->explicitVisible &&
+ (!childPrivate->extra.isAllocated() || !childPrivate->extra->effectRefCount))
continue;
if (childPrivate->itemNode()->parent())
childPrivate->itemNode()->parent()->removeChildNode(childPrivate->itemNode());
}
}
- if ((dirty & QQuickItemPrivate::Size) && itemPriv->clipNode) {
- itemPriv->clipNode->setRect(item->boundingRect());
- itemPriv->clipNode->update();
+ if ((dirty & QQuickItemPrivate::Size) && itemPriv->clipNode()) {
+ itemPriv->clipNode()->setRect(item->boundingRect());
+ itemPriv->clipNode()->update();
}
if (dirty & (QQuickItemPrivate::OpacityValue | QQuickItemPrivate::Visible
| QQuickItemPrivate::HideReference | QQuickItemPrivate::Canvas))
{
- qreal opacity = itemPriv->explicitVisible && itemPriv->hideRefCount == 0
- ? itemPriv->opacity : qreal(0);
+ qreal opacity = itemPriv->explicitVisible && (!itemPriv->extra.isAllocated() || itemPriv->extra->hideRefCount == 0)
+ ? itemPriv->opacity() : qreal(0);
- if (opacity != 1 && !itemPriv->opacityNode) {
- itemPriv->opacityNode = new QSGOpacityNode;
+ if (opacity != 1 && !itemPriv->opacityNode()) {
+ itemPriv->extra.value().opacityNode = new QSGOpacityNode;
QSGNode *parent = itemPriv->itemNode();
- QSGNode *child = itemPriv->clipNode;
+ QSGNode *child = itemPriv->clipNode();
if (!child)
- child = itemPriv->rootNode;
+ child = itemPriv->rootNode();
if (!child)
child = itemPriv->groupNode;
if (child)
parent->removeChildNode(child);
- parent->appendChildNode(itemPriv->opacityNode);
+ parent->appendChildNode(itemPriv->opacityNode());
if (child)
- itemPriv->opacityNode->appendChildNode(child);
+ itemPriv->opacityNode()->appendChildNode(child);
}
- if (itemPriv->opacityNode)
- itemPriv->opacityNode->setOpacity(opacity);
+ if (itemPriv->opacityNode())
+ itemPriv->opacityNode()->setOpacity(opacity);
}
if (dirty & QQuickItemPrivate::ContentUpdateMask) {
itemPriv->paintNode->parent() == itemPriv->childContainerNode());
if (itemPriv->paintNode && itemPriv->paintNode->parent() == 0) {
- if (itemPriv->beforePaintNode)
- itemPriv->childContainerNode()->insertChildNodeAfter(itemPriv->paintNode, itemPriv->beforePaintNode);
+ if (itemPriv->extra.isAllocated() && itemPriv->extra->beforePaintNode)
+ itemPriv->childContainerNode()->insertChildNodeAfter(itemPriv->paintNode, itemPriv->extra->beforePaintNode);
else
itemPriv->childContainerNode()->prependChildNode(itemPriv->paintNode);
}
// Check consistency.
const QSGNode *nodeChain[] = {
itemPriv->itemNodeInstance,
- itemPriv->opacityNode,
- itemPriv->clipNode,
- itemPriv->rootNode,
+ itemPriv->opacityNode(),
+ itemPriv->clipNode(),
+ itemPriv->rootNode(),
itemPriv->groupNode,
itemPriv->paintNode,
};
{
QQuickItemPrivate *p = item?QQuickItemPrivate::get(item):0;
if (p) {
- m_next = p->keyHandler;
- p->keyHandler = this;
+ m_next = p->extra.value().keyHandler;
+ p->extra->keyHandler = this;
}
}
{
if (QQuickItem *item = qobject_cast<QQuickItem*>(parent)) {
itemPrivate = QQuickItemPrivate::get(item);
- itemPrivate->attachedLayoutDirection = this;
+ itemPrivate->extra.value().layoutDirectionAttached = this;
} else
qmlInfo(parent) << tr("LayoutDirection attached property only works with Items");
}
emit _anchors->mirroredChanged();
}
mirrorChange();
- if (attachedLayoutDirection) {
- emit attachedLayoutDirection->enabledChanged();
+ if (extra.isAllocated() && extra->layoutDirectionAttached) {
+ emit extra->layoutDirectionAttached->enabledChanged();
}
}
}
}
d->changeListeners.clear();
- delete d->_anchorLines; d->_anchorLines = 0;
+
+ if (d->extra.isAllocated()) {
+ delete d->extra->contents; d->extra->contents = 0;
+ delete d->extra->layer; d->extra->layer = 0;
+ }
+
delete d->_anchors; d->_anchors = 0;
delete d->_stateGroup; d->_stateGroup = 0;
- delete d->_contents; d->_contents = 0;
- delete d->_layer;
}
/*!
// the childItems list. This is by far the most common case.
bool haveZ = false;
for (int i = 0; i < childItems.count(); ++i) {
- if (QQuickItemPrivate::get(childItems.at(i))->z != 0.) {
+ if (QQuickItemPrivate::get(childItems.at(i))->z() != 0.) {
haveZ = true;
break;
}
QQuickCanvasPrivate::get(canvas)->itemsToPolish.insert(q);
itemNodeInstance = 0;
- opacityNode = 0;
- clipNode = 0;
- rootNode = 0;
+
+ if (extra.isAllocated()) {
+ extra->opacityNode = 0;
+ extra->clipNode = 0;
+ extra->rootNode = 0;
+ extra->beforePaintNode = 0;
+ }
+
groupNode = 0;
paintNode = 0;
- beforePaintNode = 0;
InitializationState _dummy;
InitializationState *childState = state;
dirty(Canvas);
- if (screenAttached)
- screenAttached->canvasChanged(c);
+ if (extra.isAllocated() && extra->screenAttached)
+ extra->screenAttached->canvasChanged(c);
itemChange(QQuickItem::ItemSceneChange, c);
}
t = m.toTransform();
}
- if (scale != 1. || rotation != 0.) {
+ if (scale() != 1. || rotation() != 0.) {
QPointF tp = computeTransformOrigin();
t.translate(tp.x(), tp.y());
- t.scale(scale, scale);
- t.rotate(rotation);
+ t.scale(scale(), scale());
+ t.rotate(rotation());
t.translate(-tp.x(), -tp.y());
}
}
}
QQuickItemPrivate::QQuickItemPrivate()
-: _anchors(0), _contents(0), baselineOffset(0), _anchorLines(0), _stateGroup(0), origin(QQuickItem::Center),
-
- flags(0), widthValid(false), heightValid(false), componentComplete(true),
+: _anchors(0), _stateGroup(0),
+ flags(0), widthValid(false), heightValid(false), baselineOffsetValid(false), componentComplete(true),
keepMouse(false), keepTouch(false), hoverEnabled(false), smooth(false), focus(false), activeFocus(false), notifiedFocus(false),
notifiedActiveFocus(false), filtersChildMouseEvents(false), explicitVisible(true),
effectiveVisible(true), explicitEnable(true), effectiveEnable(true), polishScheduled(false),
staticSubtreeGeometry(false),
isAccessible(false),
+ dirtyAttributes(0), nextDirtyItem(0), prevDirtyItem(0),
+
canvas(0), parentItem(0), sortedChildItems(&childItems),
subFocusItem(0),
x(0), y(0), width(0), height(0), implicitWidth(0), implicitHeight(0),
- z(0), scale(1), rotation(0), opacity(1),
- attachedLayoutDirection(0), acceptedMouseButtons(0),
-
- keyHandler(0),
-
- dirtyAttributes(0), nextDirtyItem(0), prevDirtyItem(0),
+ baselineOffset(0),
- itemNodeInstance(0), opacityNode(0), clipNode(0), rootNode(0), groupNode(0), paintNode(0)
- , beforePaintNode(0), effectRefCount(0), hideRefCount(0)
- , screenAttached(0), _layer(0)
+ itemNodeInstance(0), groupNode(0), paintNode(0)
{
}
registerAccessorProperties();
- baselineOffset.invalidate();
+ baselineOffsetValid = false;
if (parent) {
q->setParentItem(parent);
int QQuickItemPrivate::transform_count(QDeclarativeListProperty<QQuickTransform> *prop)
{
QQuickItem *that = static_cast<QQuickItem *>(prop->object);
- return QQuickItemPrivate::get(that)->transforms.count();
+ QQuickItemPrivate *p = QQuickItemPrivate::get(that);
+
+ return p->transforms.count();
}
void QQuickTransform::appendToItem(QQuickItem *item)
return _anchors;
}
-QQuickItemPrivate::AnchorLines *QQuickItemPrivate::anchorLines() const
-{
- Q_Q(const QQuickItem);
- if (!_anchorLines) _anchorLines =
- new AnchorLines(const_cast<QQuickItem *>(q));
- return _anchorLines;
-}
-
void QQuickItemPrivate::siblingOrderChanged()
{
Q_Q(QQuickItem);
QRectF QQuickItem::childrenRect()
{
Q_D(QQuickItem);
- if (!d->_contents) {
- d->_contents = new QQuickContents(this);
+ if (!d->extra.isAllocated() || !d->extra->contents) {
+ d->extra.value().contents = new QQuickContents(this);
if (d->componentComplete)
- d->_contents->complete();
+ d->extra->contents->complete();
}
- return d->_contents->rectF();
+ return d->extra->contents->rectF();
}
QList<QQuickItem *> QQuickItem::childItems() const
{
}
+void QQuickItemPrivate::addItemChangeListener(QQuickItemChangeListener *listener, ChangeTypes types)
+{
+ changeListeners.append(ChangeListener(listener, types));
+}
+
void QQuickItemPrivate::removeItemChangeListener(QQuickItemChangeListener *listener, ChangeTypes types)
{
ChangeListener change(listener, types);
changeListeners.append(change);
}
-void QQuickItemPrivate::updateOrRemoveGeometryChangeListener(QQuickItemChangeListener *listener, GeometryChangeTypes types)
+void QQuickItemPrivate::updateOrRemoveGeometryChangeListener(QQuickItemChangeListener *listener,
+ GeometryChangeTypes types)
{
ChangeListener change(listener, types);
if (types == NoChange) {
case Qt::ImMaximumTextLength:
case Qt::ImAnchorPosition:
case Qt::ImPreferredLanguage:
- if (d->keyHandler)
- v = d->keyHandler->inputMethodQuery(query);
+ if (d->extra.isAllocated() && d->extra->keyHandler)
+ v = d->extra->keyHandler->inputMethodQuery(query);
default:
break;
}
QQuickAnchorLine QQuickItemPrivate::left() const
{
- return anchorLines()->left;
+ Q_Q(const QQuickItem);
+ return QQuickAnchorLine(const_cast<QQuickItem *>(q), QQuickAnchorLine::Left);
}
QQuickAnchorLine QQuickItemPrivate::right() const
{
- return anchorLines()->right;
+ Q_Q(const QQuickItem);
+ return QQuickAnchorLine(const_cast<QQuickItem *>(q), QQuickAnchorLine::Right);
}
QQuickAnchorLine QQuickItemPrivate::horizontalCenter() const
{
- return anchorLines()->hCenter;
+ Q_Q(const QQuickItem);
+ return QQuickAnchorLine(const_cast<QQuickItem *>(q), QQuickAnchorLine::HCenter);
}
QQuickAnchorLine QQuickItemPrivate::top() const
{
- return anchorLines()->top;
+ Q_Q(const QQuickItem);
+ return QQuickAnchorLine(const_cast<QQuickItem *>(q), QQuickAnchorLine::Top);
}
QQuickAnchorLine QQuickItemPrivate::bottom() const
{
- return anchorLines()->bottom;
+ Q_Q(const QQuickItem);
+ return QQuickAnchorLine(const_cast<QQuickItem *>(q), QQuickAnchorLine::Bottom);
}
QQuickAnchorLine QQuickItemPrivate::verticalCenter() const
{
- return anchorLines()->vCenter;
+ Q_Q(const QQuickItem);
+ return QQuickAnchorLine(const_cast<QQuickItem *>(q), QQuickAnchorLine::VCenter);
}
QQuickAnchorLine QQuickItemPrivate::baseline() const
{
- return anchorLines()->baseline;
+ Q_Q(const QQuickItem);
+ return QQuickAnchorLine(const_cast<QQuickItem *>(q), QQuickAnchorLine::Baseline);
}
qreal QQuickItem::baselineOffset() const
{
Q_D(const QQuickItem);
- if (!d->baselineOffset.isValid()) {
- return 0.0;
- } else
+ if (d->baselineOffsetValid) {
return d->baselineOffset;
+ } else {
+ return 0.0;
+ }
}
void QQuickItem::setBaselineOffset(qreal offset)
return;
d->baselineOffset = offset;
+ d->baselineOffsetValid = true;
for (int ii = 0; ii < d->changeListeners.count(); ++ii) {
const QQuickItemPrivate::ChangeListener &change = d->changeListeners.at(ii);
d->_stateGroup->classBegin();
if (d->_anchors)
d->_anchors->classBegin();
- if (d->_layer)
- d->_layer->classBegin();
+ if (d->extra.isAllocated() && d->extra->layer)
+ d->extra->layer->classBegin();
}
void QQuickItem::componentComplete()
QQuickAnchorsPrivate::get(d->_anchors)->updateOnComplete();
}
- if (d->_layer)
- d->_layer->componentComplete();
+ if (d->extra.isAllocated() && d->extra->layer)
+ d->extra->layer->componentComplete();
+
+ if (d->extra.isAllocated() && d->extra->keyHandler)
+ d->extra->keyHandler->componentComplete();
- if (d->keyHandler)
- d->keyHandler->componentComplete();
- if (d->_contents)
- d->_contents->complete();
+ if (d->extra.isAllocated() && d->extra->contents)
+ d->extra->contents->complete();
}
QDeclarativeStateGroup *QQuickItemPrivate::_states()
return _stateGroup;
}
-QQuickItemPrivate::AnchorLines::AnchorLines(QQuickItem *q)
-{
- left.item = q;
- left.anchorLine = QQuickAnchorLine::Left;
- right.item = q;
- right.anchorLine = QQuickAnchorLine::Right;
- hCenter.item = q;
- hCenter.anchorLine = QQuickAnchorLine::HCenter;
- top.item = q;
- top.anchorLine = QQuickAnchorLine::Top;
- bottom.item = q;
- bottom.anchorLine = QQuickAnchorLine::Bottom;
- vCenter.item = q;
- vCenter.anchorLine = QQuickAnchorLine::VCenter;
- baseline.item = q;
- baseline.anchorLine = QQuickAnchorLine::Baseline;
-}
-
QPointF QQuickItemPrivate::computeTransformOrigin() const
{
- switch (origin) {
+ switch (origin()) {
default:
case QQuickItem::TopLeft:
return QPointF(0, 0);
void QQuickItemPrivate::transformChanged()
{
- if (_layer)
- _layer->updateMatrix();
+ if (extra.isAllocated() && extra->layer)
+ extra->layer->updateMatrix();
}
void QQuickItemPrivate::deliverKeyEvent(QKeyEvent *e)
Q_Q(QQuickItem);
Q_ASSERT(e->isAccepted());
- if (keyHandler) {
+ if (extra.isAllocated() && extra->keyHandler) {
if (e->type() == QEvent::KeyPress)
- keyHandler->keyPressed(e, false);
+ extra->keyHandler->keyPressed(e, false);
else
- keyHandler->keyReleased(e, false);
+ extra->keyHandler->keyReleased(e, false);
if (e->isAccepted())
return;
if (e->isAccepted())
return;
- if (keyHandler) {
+ if (extra.isAllocated() && extra->keyHandler) {
e->accept();
if (e->type() == QEvent::KeyPress)
- keyHandler->keyPressed(e, true);
+ extra->keyHandler->keyPressed(e, true);
else
- keyHandler->keyReleased(e, true);
+ extra->keyHandler->keyReleased(e, true);
}
}
Q_Q(QQuickItem);
Q_ASSERT(e->isAccepted());
- if (keyHandler) {
- keyHandler->inputMethodEvent(e, false);
+ if (extra.isAllocated() && extra->keyHandler) {
+ extra->keyHandler->inputMethodEvent(e, false);
if (e->isAccepted())
return;
if (e->isAccepted())
return;
- if (keyHandler) {
+ if (extra.isAllocated() && extra->keyHandler) {
e->accept();
- keyHandler->inputMethodEvent(e, true);
+ extra->keyHandler->inputMethodEvent(e, true);
}
}
QQuickItem::TransformOrigin QQuickItem::transformOrigin() const
{
Q_D(const QQuickItem);
- return d->origin;
+ return d->origin();
}
void QQuickItem::setTransformOrigin(TransformOrigin origin)
{
Q_D(QQuickItem);
- if (origin == d->origin)
+ if (origin == d->origin())
return;
- d->origin = origin;
+ d->extra.value().origin = origin;
d->dirty(QQuickItemPrivate::TransformOrigin);
- emit transformOriginChanged(d->origin);
+ emit transformOriginChanged(d->origin());
}
QPointF QQuickItem::transformOriginPoint() const
{
Q_D(const QQuickItem);
- if (!d->transformOriginPoint.isNull())
- return d->transformOriginPoint;
+ if (d->extra.isAllocated() && !d->extra->userTransformOriginPoint.isNull())
+ return d->extra->userTransformOriginPoint;
return d->computeTransformOrigin();
}
void QQuickItem::setTransformOriginPoint(const QPointF &point)
{
Q_D(QQuickItem);
- if (d->transformOriginPoint == point)
+ if (d->extra.value().userTransformOriginPoint == point)
return;
- d->transformOriginPoint = point;
+ d->extra->userTransformOriginPoint = point;
d->dirty(QQuickItemPrivate::TransformOrigin);
}
qreal QQuickItem::z() const
{
Q_D(const QQuickItem);
- return d->z;
+ return d->z();
}
void QQuickItem::setZ(qreal v)
{
Q_D(QQuickItem);
- if (d->z == v)
+ if (d->z() == v)
return;
- d->z = v;
+ d->extra.value().z = v;
d->dirty(QQuickItemPrivate::ZValue);
if (d->parentItem) {
emit zChanged();
- if (d->_layer)
- d->_layer->updateZ();
+ if (d->extra.isAllocated() && d->extra->layer)
+ d->extra->layer->updateZ();
}
qreal QQuickItem::rotation() const
{
Q_D(const QQuickItem);
- return d->rotation;
+ return d->rotation();
}
void QQuickItem::setRotation(qreal r)
{
Q_D(QQuickItem);
- if (d->rotation == r)
+ if (d->rotation() == r)
return;
- d->rotation = r;
+ d->extra.value().rotation = r;
d->dirty(QQuickItemPrivate::BasicTransform);
qreal QQuickItem::scale() const
{
Q_D(const QQuickItem);
- return d->scale;
+ return d->scale();
}
void QQuickItem::setScale(qreal s)
{
Q_D(QQuickItem);
- if (d->scale == s)
+ if (d->scale() == s)
return;
- d->scale = s;
+ d->extra.value().scale = s;
d->dirty(QQuickItemPrivate::BasicTransform);
qreal QQuickItem::opacity() const
{
Q_D(const QQuickItem);
- return d->opacity;
+ return d->opacity();
}
void QQuickItem::setOpacity(qreal o)
{
Q_D(QQuickItem);
- if (d->opacity == o)
+ if (d->opacity() == o)
return;
- d->opacity = o;
+ d->extra.value().opacity = o;
d->dirty(QQuickItemPrivate::OpacityValue);
void QQuickItemPrivate::refFromEffectItem(bool hide)
{
- ++effectRefCount;
- if (1 == effectRefCount) {
+ ++extra.value().effectRefCount;
+ if (1 == extra->effectRefCount) {
dirty(EffectReference);
if (parentItem) QQuickItemPrivate::get(parentItem)->dirty(ChildrenStackingChanged);
}
if (hide) {
- if (++hideRefCount == 1)
+ if (++extra->hideRefCount == 1)
dirty(HideReference);
}
}
void QQuickItemPrivate::derefFromEffectItem(bool unhide)
{
- Q_ASSERT(effectRefCount);
- --effectRefCount;
- if (0 == effectRefCount) {
+ Q_ASSERT(extra->effectRefCount);
+ --extra->effectRefCount;
+ if (0 == extra->effectRefCount) {
dirty(EffectReference);
if (parentItem) QQuickItemPrivate::get(parentItem)->dirty(ChildrenStackingChanged);
}
if (unhide) {
- if (--hideRefCount == 0)
+ if (--extra->hideRefCount == 0)
dirty(HideReference);
}
}
Qt::MouseButtons QQuickItem::acceptedMouseButtons() const
{
Q_D(const QQuickItem);
- return d->acceptedMouseButtons;
+ return d->acceptedMouseButtons();
}
void QQuickItem::setAcceptedMouseButtons(Qt::MouseButtons buttons)
{
Q_D(QQuickItem);
- d->acceptedMouseButtons = buttons;
+ if (buttons & Qt::LeftButton)
+ d->extra.setFlag();
+ else
+ d->extra.clearFlag();
+
+ buttons &= ~Qt::LeftButton;
+ if (buttons || d->extra.isAllocated())
+ d->extra.value().acceptedMouseButtons = buttons;
}
bool QQuickItem::filtersChildMouseEvents() const
bool QQuickItem::isTextureProvider() const
{
Q_D(const QQuickItem);
- return d->_layer && d->_layer->effectSource() ? d->_layer->effectSource()->isTextureProvider() : false;
+ return d->extra.isAllocated() && d->extra->layer && d->extra->layer->effectSource() ?
+ d->extra->layer->effectSource()->isTextureProvider() : false;
}
/*!
QSGTextureProvider *QQuickItem::textureProvider() const
{
Q_D(const QQuickItem);
- return d->_layer && d->_layer->effectSource() ? d->_layer->effectSource()->textureProvider() : 0;
+ return d->extra.isAllocated() && d->extra->layer && d->extra->layer->effectSource() ?
+ d->extra->layer->effectSource()->textureProvider() : 0;
}
-
-
QQuickItemLayer *QQuickItemPrivate::layer() const
{
- if (!_layer) {
- _layer = new QQuickItemLayer(const_cast<QQuickItem *>(q_func()));
+ if (!extra.isAllocated() || !extra->layer) {
+ extra.value().layer = new QQuickItemLayer(const_cast<QQuickItem *>(q_func()));
if (!componentComplete)
- _layer->classBegin();
+ extra->layer->classBegin();
}
- return _layer;
+ return extra->layer;
}
-
-
QQuickItemLayer::QQuickItemLayer(QQuickItem *item)
: m_item(item)
, m_enabled(false)
l->setScale(m_item->scale());
l->setRotation(m_item->rotation());
ld->transforms = QQuickItemPrivate::get(m_item)->transforms;
- ld->origin = QQuickItemPrivate::get(m_item)->origin;
+ if (ld->origin() != QQuickItemPrivate::get(m_item)->origin())
+ ld->extra.value().origin = QQuickItemPrivate::get(m_item)->origin();
ld->dirty(QQuickItemPrivate::Transform);
}
+QQuickItemPrivate::ExtraData::ExtraData()
+: z(0), scale(1), rotation(0), opacity(1),
+ contents(0), screenAttached(0), layoutDirectionAttached(0),
+ keyHandler(0), layer(0), effectRefCount(0), hideRefCount(0),
+ opacityNode(0), clipNode(0), rootNode(0), beforePaintNode(0),
+ acceptedMouseButtons(0), origin(QQuickItem::Center)
+{
+}
+
QT_END_NAMESPACE
#include <moc_qquickitem.cpp>
#include <private/qdeclarativenullablevalue_p_p.h>
#include <private/qdeclarativenotifier_p.h>
#include <private/qdeclarativeglobal_p.h>
+#include <private/qlazilyallocated_p.h>
#include <qdeclarative.h>
#include <qdeclarativecontext.h>
static QQuickTransform *transform_at(QDeclarativeListProperty<QQuickTransform> *list, int);
static void transform_clear(QDeclarativeListProperty<QQuickTransform> *list);
- QQuickAnchors *anchors() const;
- mutable QQuickAnchors *_anchors;
- QQuickContents *_contents;
-
- QDeclarativeNullableValue<qreal> baselineOffset;
-
- struct AnchorLines {
- AnchorLines(QQuickItem *);
- QQuickAnchorLine left;
- QQuickAnchorLine right;
- QQuickAnchorLine hCenter;
- QQuickAnchorLine top;
- QQuickAnchorLine bottom;
- QQuickAnchorLine vCenter;
- QQuickAnchorLine baseline;
- };
- mutable AnchorLines *_anchorLines;
- AnchorLines *anchorLines() const;
-
enum ChangeType {
Geometry = 0x01,
SiblingOrder = 0x02,
bool operator==(const ChangeListener &other) const { return listener == other.listener && types == other.types; }
};
- void addItemChangeListener(QQuickItemChangeListener *listener, ChangeTypes types) {
- changeListeners.append(ChangeListener(listener, types));
- }
+ struct ExtraData {
+ ExtraData();
+
+ qreal z;
+ qreal scale;
+ qreal rotation;
+ qreal opacity;
+
+ QQuickContents *contents;
+ QQuickScreenAttached *screenAttached;
+ QQuickLayoutMirroringAttached* layoutDirectionAttached;
+ QQuickItemKeyFilter *keyHandler;
+ mutable QQuickItemLayer *layer;
+ QPointF userTransformOriginPoint;
+
+ int effectRefCount;
+ int hideRefCount;
+
+ QSGOpacityNode *opacityNode;
+ QQuickDefaultClipNode *clipNode;
+ QSGRootNode *rootNode;
+ QSGNode *beforePaintNode;
+
+ // Although acceptedMouseButtons is inside ExtraData, we actually store
+ // the LeftButton flag in the extra.flag() bit. This is because it is
+ // extremely common to set acceptedMouseButtons to LeftButton, but very
+ // rare to use any of the other buttons.
+ Qt::MouseButtons acceptedMouseButtons;
+
+ QQuickItem::TransformOrigin origin:5;
+ };
+ QLazilyAllocated<ExtraData> extra;
+
+ QQuickAnchors *anchors() const;
+ mutable QQuickAnchors *_anchors;
+
+ inline Qt::MouseButtons acceptedMouseButtons() const;
+
+ QPODVector<QQuickItemPrivate::ChangeListener,4> changeListeners;
+
+ void addItemChangeListener(QQuickItemChangeListener *listener, ChangeTypes types);
void removeItemChangeListener(QQuickItemChangeListener *, ChangeTypes types);
void updateOrAddGeometryChangeListener(QQuickItemChangeListener *listener, GeometryChangeTypes types);
void updateOrRemoveGeometryChangeListener(QQuickItemChangeListener *listener, GeometryChangeTypes types);
- QPODVector<ChangeListener,4> changeListeners;
QDeclarativeStateGroup *_states();
QDeclarativeStateGroup *_stateGroup;
- QQuickItem::TransformOrigin origin:5;
+ inline QQuickItem::TransformOrigin origin() const;
+
+ // Bit 0
quint32 flags:5;
bool widthValid:1;
bool heightValid:1;
+ bool baselineOffsetValid:1;
bool componentComplete:1;
bool keepMouse:1;
bool keepTouch:1;
bool focus:1;
bool activeFocus:1;
bool notifiedFocus:1;
+ // Bit 16
bool notifiedActiveFocus:1;
bool filtersChildMouseEvents:1;
bool explicitVisible:1;
bool childrenDoNotOverlap:1;
bool staticSubtreeGeometry:1;
bool isAccessible:1;
+ // bool dummy:1
+ // Bit 32
+
+ enum DirtyType {
+ TransformOrigin = 0x00000001,
+ Transform = 0x00000002,
+ BasicTransform = 0x00000004,
+ Position = 0x00000008,
+ Size = 0x00000010,
+
+ ZValue = 0x00000020,
+ Content = 0x00000040,
+ Smooth = 0x00000080,
+ OpacityValue = 0x00000100,
+ ChildrenChanged = 0x00000200,
+ ChildrenStackingChanged = 0x00000400,
+ ParentChanged = 0x00000800,
+
+ Clip = 0x00001000,
+ Canvas = 0x00002000,
+
+ EffectReference = 0x00008000,
+ Visible = 0x00010000,
+ HideReference = 0x00020000,
+ PerformanceHints = 0x00040000,
+ // When you add an attribute here, don't forget to update
+ // dirtyToString()
+
+ TransformUpdateMask = TransformOrigin | Transform | BasicTransform | Position |
+ Size | Canvas,
+ ComplexTransformUpdateMask = Transform | Canvas,
+ ContentUpdateMask = Size | Content | Smooth | Canvas,
+ ChildrenUpdateMask = ChildrenChanged | ChildrenStackingChanged | EffectReference | Canvas
+ };
+
+ quint32 dirtyAttributes;
+ QString dirtyToString() const;
+ void dirty(DirtyType);
+ void addToDirtyList();
+ void removeFromDirtyList();
+ QQuickItem *nextDirtyItem;
+ QQuickItem**prevDirtyItem;
QQuickCanvas *canvas;
- QSGContext *sceneGraphContext() const { Q_ASSERT(canvas); return static_cast<QQuickCanvasPrivate *>(QObjectPrivate::get(canvas))->context; }
+ inline QSGContext *sceneGraphContext() const;
QQuickItem *parentItem;
QDeclarativeNotifier parentNotifier;
void removeChild(QQuickItem *);
void siblingOrderChanged();
- inline void markSortedChildrenDirty(QQuickItem *child) {
- // If sortedChildItems == &childItems then all in childItems have z == 0
- // and we don't need to invalidate if the changed item also has z == 0.
- if (child->z() != 0. || sortedChildItems != &childItems) {
- if (sortedChildItems != &childItems)
- delete sortedChildItems;
- sortedChildItems = 0;
- }
- }
+ inline void markSortedChildrenDirty(QQuickItem *child);
class InitializationState {
public:
qreal implicitWidth;
qreal implicitHeight;
- qreal z;
- qreal scale;
- qreal rotation;
- qreal opacity;
+ qreal baselineOffset;
- QQuickLayoutMirroringAttached* attachedLayoutDirection;
+ QList<QQuickTransform *> transforms;
- Qt::MouseButtons acceptedMouseButtons;
+ inline qreal z() const { return extra.isAllocated()?extra->z:0; }
+ inline qreal scale() const { return extra.isAllocated()?extra->scale:1; }
+ inline qreal rotation() const { return extra.isAllocated()?extra->rotation:0; }
+ inline qreal opacity() const { return extra.isAllocated()?extra->opacity:1; }
void setAccessibleFlagAndListener();
- QPointF transformOriginPoint;
-
virtual qreal getImplicitWidth() const;
virtual qreal getImplicitHeight() const;
virtual void implicitWidthChanged();
}
QPointF computeTransformOrigin() const;
- QList<QQuickTransform *> transforms;
virtual void transformChanged();
- QQuickItemKeyFilter *keyHandler;
void deliverKeyEvent(QKeyEvent *);
void deliverInputMethodEvent(QInputMethodEvent *);
void deliverFocusEvent(QFocusEvent *);
bool calcEffectiveEnable() const;
void setEffectiveEnableRecur(QQuickItem *scope, bool);
- // XXX todo
- enum DirtyType {
- TransformOrigin = 0x00000001,
- Transform = 0x00000002,
- BasicTransform = 0x00000004,
- Position = 0x00000008,
- Size = 0x00000010,
-
- ZValue = 0x00000020,
- Content = 0x00000040,
- Smooth = 0x00000080,
- OpacityValue = 0x00000100,
- ChildrenChanged = 0x00000200,
- ChildrenStackingChanged = 0x00000400,
- ParentChanged = 0x00000800,
-
- Clip = 0x00001000,
- Canvas = 0x00002000,
-
- EffectReference = 0x00008000,
- Visible = 0x00010000,
- HideReference = 0x00020000,
- PerformanceHints = 0x00040000,
- // When you add an attribute here, don't forget to update
- // dirtyToString()
-
- TransformUpdateMask = TransformOrigin | Transform | BasicTransform | Position | Size | Canvas,
- ComplexTransformUpdateMask = Transform | Canvas,
- ContentUpdateMask = Size | Content | Smooth | Canvas,
- ChildrenUpdateMask = ChildrenChanged | ChildrenStackingChanged | EffectReference | Canvas
-
- };
- quint32 dirtyAttributes;
- QString dirtyToString() const;
- void dirty(DirtyType);
- void addToDirtyList();
- void removeFromDirtyList();
- QQuickItem *nextDirtyItem;
- QQuickItem**prevDirtyItem;
inline QSGTransformNode *itemNode();
inline QSGNode *childContainerNode();
- groupNode
*/
+ QSGOpacityNode *opacityNode() const { return extra.isAllocated()?extra->opacityNode:0; }
+ QQuickDefaultClipNode *clipNode() const { return extra.isAllocated()?extra->clipNode:0; }
+ QSGRootNode *rootNode() const { return extra.isAllocated()?extra->rootNode:0; }
+
QSGTransformNode *itemNodeInstance;
- QSGOpacityNode *opacityNode;
- QQuickDefaultClipNode *clipNode;
- QSGRootNode *rootNode;
QSGNode *groupNode;
QSGNode *paintNode;
- QSGNode *beforePaintNode;
virtual QSGTransformNode *createTransformNode();
// it should insert a root node.
void refFromEffectItem(bool hide);
void derefFromEffectItem(bool unhide);
- int effectRefCount;
- int hideRefCount;
void itemChange(QQuickItem::ItemChange, const QQuickItem::ItemChangeData &);
virtual void mirrorChange() {}
- QQuickScreenAttached *screenAttached;
-
- mutable QQuickItemLayer *_layer;
-
static qint64 consistentTime;
static void setConsistentTime(qint64 t);
static void start(QElapsedTimer &);
static const SigMap sigMap[];
};
+Qt::MouseButtons QQuickItemPrivate::acceptedMouseButtons() const
+{
+ return extra.flag()?Qt::LeftButton:Qt::MouseButton(0) |
+ (extra.isAllocated()?extra->acceptedMouseButtons:Qt::MouseButtons(0));
+}
+
+QSGContext *QQuickItemPrivate::sceneGraphContext() const
+{
+ Q_ASSERT(canvas);
+ return static_cast<QQuickCanvasPrivate *>(QObjectPrivate::get(canvas))->context;
+}
+
+void QQuickItemPrivate::markSortedChildrenDirty(QQuickItem *child)
+{
+ // If sortedChildItems == &childItems then all in childItems have z == 0
+ // and we don't need to invalidate if the changed item also has z == 0.
+ if (child->z() != 0. || sortedChildItems != &childItems) {
+ if (sortedChildItems != &childItems)
+ delete sortedChildItems;
+ sortedChildItems = 0;
+ }
+}
+
+QQuickItem::TransformOrigin QQuickItemPrivate::origin() const
+{
+ return extra.isAllocated()?extra->origin:QQuickItem::Center;
+}
+
QSGTransformNode *QQuickItemPrivate::itemNode()
{
if (!itemNodeInstance) {
{
if (!groupNode) {
groupNode = new QSGNode();
- if (rootNode)
- rootNode->appendChildNode(groupNode);
- else if (clipNode)
- clipNode->appendChildNode(groupNode);
- else if (opacityNode)
- opacityNode->appendChildNode(groupNode);
+ if (rootNode())
+ rootNode()->appendChildNode(groupNode);
+ else if (clipNode())
+ clipNode()->appendChildNode(groupNode);
+ else if (opacityNode())
+ opacityNode()->appendChildNode(groupNode);
else
itemNode()->appendChildNode(groupNode);
groupNode->setFlag(QSGNode::ChildrenDoNotOverlap, childrenDoNotOverlap);
//But specific to MouseArea, so doesn't belong in canvas
Q_Q(const QQuickMouseArea);
QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
- if (itemPrivate->opacity == 0.0)
+ if (itemPrivate->opacity() == 0.0)
return false;
if (itemPrivate->flags & QQuickItem::ItemClipsChildrenToShape) {
}
QQuickMouseArea* ma = qobject_cast<QQuickMouseArea*>(item);
- if (ma && ma != q && itemPrivate->acceptedMouseButtons & ev->button()) {
+ if (ma && ma != q && itemPrivate->acceptedMouseButtons() & ev->button()) {
switch (sig) {
case Click:
if (!ma->d_func()->isClickConnected())
m_attachee = qobject_cast<QQuickItem*>(attachee);
if (m_attachee) {
- QQuickItemPrivate::get(m_attachee)->screenAttached = this;
+ QQuickItemPrivate::get(m_attachee)->extra.value().screenAttached = this;
if (m_attachee->canvas()) //It might not be assigned to a canvas yet
canvasChanged(m_attachee->canvas());
projects / profile / ivi / qtdeclarative.git / commitdiff