void QDeclarativeAnchorsPrivate::updateHorizontalAnchors()
{
if (fill || centerIn || !isItemComplete())
return;
if (updatingHorizontalAnchor < 2) {
++updatingHorizontalAnchor;
QGraphicsItemPrivate *itemPrivate = QGraphicsItemPrivate::get(item);
if (usedAnchors & QDeclarativeAnchors::LeftAnchor) {
//Handle stretching
bool invalid = true;
int width = 0;
if (usedAnchors & QDeclarativeAnchors::RightAnchor) {
invalid = calcStretch(left, right, leftMargin, -rightMargin, QDeclarativeAnchorLine::Left, width);
} else if (usedAnchors & QDeclarativeAnchors::HCenterAnchor) {
invalid = calcStretch(left, hCenter, leftMargin, hCenterOffset, QDeclarativeAnchorLine::Left, width);
width *= 2;
}
if (!invalid)
setItemWidth(width);
//Handle left
if (left.item == item->parentItem()) {
setItemX(adjustedPosition(left.item, left.anchorLine) + leftMargin);
} else if (left.item->parentItem() == item->parentItem()) {
setItemX(position(left.item, left.anchorLine) + leftMargin);
}
} else if (usedAnchors & QDeclarativeAnchors::RightAnchor) {
//Handle stretching (left + right case is handled in updateLeftAnchor)
if (usedAnchors & QDeclarativeAnchors::HCenterAnchor) {
int width = 0;
bool invalid = calcStretch(hCenter, right, hCenterOffset, -rightMargin,
QDeclarativeAnchorLine::Left, width);
if (!invalid)
setItemWidth(width*2);
}
//Handle right
if (right.item == item->parentItem()) {
setItemX(adjustedPosition(right.item, right.anchorLine) - itemPrivate->width() - rightMargin);
} else if (right.item->parentItem() == item->parentItem()) {
setItemX(position(right.item, right.anchorLine) - itemPrivate->width() - rightMargin);
}
} else if (usedAnchors & QDeclarativeAnchors::HCenterAnchor) {
//Handle hCenter
if (hCenter.item == item->parentItem()) {
setItemX(adjustedPosition(hCenter.item, hCenter.anchorLine) - itemPrivate->width()/2 + hCenterOffset);
} else if (hCenter.item->parentItem() == item->parentItem()) {
setItemX(position(hCenter.item, hCenter.anchorLine) - itemPrivate->width()/2 + hCenterOffset);
}
}
--updatingHorizontalAnchor;
} else {
// ### Make this certain :)
qmlInfo(item) << QDeclarativeAnchors::tr("Possible anchor loop detected on horizontal anchor.");
}
}
void TextureMapperLayer::flushCompositingStateForThisLayerOnly(GraphicsLayerTextureMapper* graphicsLayer)
{
ASSERT(graphicsLayer);
int changeMask = graphicsLayer->changeMask();
if (changeMask == NoChanges && graphicsLayer->m_animations.isEmpty())
return;
graphicsLayer->updateDebugIndicators();
if (changeMask & ChildrenChange)
setChildren(graphicsLayer->children());
if (changeMask & MaskLayerChange) {
if (TextureMapperLayer* layer = toTextureMapperLayer(graphicsLayer->maskLayer()))
layer->m_effectTarget = this;
}
if (changeMask & ReplicaLayerChange) {
if (TextureMapperLayer* layer = toTextureMapperLayer(graphicsLayer->replicaLayer()))
layer->m_effectTarget = this;
}
if (changeMask & AnimationChange)
m_animations = graphicsLayer->m_animations;
m_state.maskLayer = toTextureMapperLayer(graphicsLayer->maskLayer());
m_state.replicaLayer = toTextureMapperLayer(graphicsLayer->replicaLayer());
m_state.pos = graphicsLayer->position();
m_state.anchorPoint = graphicsLayer->anchorPoint();
m_state.size = graphicsLayer->size();
m_state.transform = graphicsLayer->transform();
m_state.contentsRect = graphicsLayer->contentsRect();
m_state.preserves3D = graphicsLayer->preserves3D();
m_state.masksToBounds = graphicsLayer->masksToBounds();
m_state.drawsContent = graphicsLayer->drawsContent();
m_state.contentsVisible = graphicsLayer->contentsAreVisible();
m_state.contentsOpaque = graphicsLayer->contentsOpaque();
m_state.backfaceVisibility = graphicsLayer->backfaceVisibility();
m_state.childrenTransform = graphicsLayer->childrenTransform();
m_state.opacity = graphicsLayer->opacity();
m_state.solidColor = graphicsLayer->solidColor();
#if ENABLE(CSS_FILTERS)
if (changeMask & FilterChange)
m_state.filters = graphicsLayer->filters();
#endif
m_fixedToViewport = graphicsLayer->fixedToViewport();
m_contentsLayer = graphicsLayer->platformLayer();
m_transform.setPosition(adjustedPosition());
m_transform.setAnchorPoint(m_state.anchorPoint);
m_transform.setSize(m_state.size);
m_transform.setFlattening(!m_state.preserves3D);
m_transform.setChildrenTransform(m_state.childrenTransform);
syncAnimations();
}
void TextureMapperLayer::scrollBy(const FloatSize& offset)
{
if (!isScrollable() || !m_scrollClient || offset.isZero())
return;
FloatSize scrollOffset = mapScrollOffset(offset);
m_userScrollOffset += scrollOffset;
m_currentTransform.setPosition(adjustedPosition());
commitScrollOffset(scrollOffset);
}
void TextureMapperLayer::setScrollPositionDeltaIfNeeded(const FloatSize& delta)
{
// delta is the difference between the scroll offset in the ui process and the scroll offset
// in the web process. We add this delta to the position of fixed layers, to make
// sure that they do not move while scrolling. We need to reset this delta to fixed layers
// that have an ancestor which is also a fixed layer, because the delta will be added to the ancestor.
if (isAncestorFixedToViewport())
m_scrollPositionDelta = FloatSize();
else
m_scrollPositionDelta = delta;
m_currentTransform.setPosition(adjustedPosition());
}
void GraphicsLayerClutter::updateGeometry(float pageScaleFactor, const FloatPoint& positionRelativeToBase)
{
FloatPoint scaledPosition;
FloatPoint3D scaledAnchorPoint;
FloatSize scaledSize;
// FIXME: Need to support scaling
scaledPosition = m_position;
scaledAnchorPoint = m_anchorPoint;
scaledSize = m_size;
FloatRect adjustedBounds(m_boundsOrigin , scaledSize);
FloatPoint adjustedPosition(scaledPosition.x() + scaledAnchorPoint.x() * scaledSize.width(), scaledPosition.y() + scaledAnchorPoint.y() * scaledSize.height());
clutter_actor_set_size(CLUTTER_ACTOR(m_layer.get()), adjustedBounds.width(), adjustedBounds.height());
clutter_actor_set_position(CLUTTER_ACTOR(m_layer.get()), adjustedPosition.x(), adjustedPosition.y());
graphicsLayerActorSetAnchorPoint(m_layer.get(), scaledAnchorPoint.x(), scaledAnchorPoint.y(), scaledAnchorPoint.z());
}
void QDeclarativeAnchorsPrivate::updateHorizontalAnchors()
{
Q_Q(QDeclarativeAnchors);
if (fill || centerIn || !isItemComplete())
return;
if (updatingHorizontalAnchor < 3) {
++updatingHorizontalAnchor;
qreal effectiveRightMargin, effectiveLeftMargin, effectiveHorizontalCenterOffset;
QDeclarativeAnchorLine effectiveLeft, effectiveRight, effectiveHorizontalCenter;
QDeclarativeAnchors::Anchor effectiveLeftAnchor, effectiveRightAnchor;
if (q->mirrored()) {
effectiveLeftAnchor = QDeclarativeAnchors::RightAnchor;
effectiveRightAnchor = QDeclarativeAnchors::LeftAnchor;
effectiveLeft.item = right.item;
effectiveLeft.anchorLine = reverseAnchorLine(right.anchorLine);
effectiveRight.item = left.item;
effectiveRight.anchorLine = reverseAnchorLine(left.anchorLine);
effectiveHorizontalCenter.item = hCenter.item;
effectiveHorizontalCenter.anchorLine = reverseAnchorLine(hCenter.anchorLine);
effectiveLeftMargin = rightMargin;
effectiveRightMargin = leftMargin;
effectiveHorizontalCenterOffset = -hCenterOffset;
} else {
effectiveLeftAnchor = QDeclarativeAnchors::LeftAnchor;
effectiveRightAnchor = QDeclarativeAnchors::RightAnchor;
effectiveLeft = left;
effectiveRight = right;
effectiveHorizontalCenter = hCenter;
effectiveLeftMargin = leftMargin;
effectiveRightMargin = rightMargin;
effectiveHorizontalCenterOffset = hCenterOffset;
}
QGraphicsItemPrivate *itemPrivate = QGraphicsItemPrivate::get(item);
if (usedAnchors & effectiveLeftAnchor) {
//Handle stretching
bool invalid = true;
qreal width = 0.0;
if (usedAnchors & effectiveRightAnchor) {
invalid = calcStretch(effectiveLeft, effectiveRight, effectiveLeftMargin, -effectiveRightMargin, QDeclarativeAnchorLine::Left, width);
} else if (usedAnchors & QDeclarativeAnchors::HCenterAnchor) {
invalid = calcStretch(effectiveLeft, effectiveHorizontalCenter, effectiveLeftMargin, effectiveHorizontalCenterOffset, QDeclarativeAnchorLine::Left, width);
width *= 2;
}
if (!invalid)
setItemWidth(width);
//Handle left
if (effectiveLeft.item == item->parentItem()) {
setItemX(adjustedPosition(effectiveLeft.item, effectiveLeft.anchorLine) + effectiveLeftMargin);
} else if (effectiveLeft.item->parentItem() == item->parentItem()) {
setItemX(position(effectiveLeft.item, effectiveLeft.anchorLine) + effectiveLeftMargin);
}
} else if (usedAnchors & effectiveRightAnchor) {
//Handle stretching (left + right case is handled in updateLeftAnchor)
if (usedAnchors & QDeclarativeAnchors::HCenterAnchor) {
qreal width = 0.0;
bool invalid = calcStretch(effectiveHorizontalCenter, effectiveRight, effectiveHorizontalCenterOffset, -effectiveRightMargin,
QDeclarativeAnchorLine::Left, width);
if (!invalid)
setItemWidth(width*2);
}
//Handle right
if (effectiveRight.item == item->parentItem()) {
setItemX(adjustedPosition(effectiveRight.item, effectiveRight.anchorLine) - itemPrivate->width() - effectiveRightMargin);
} else if (effectiveRight.item->parentItem() == item->parentItem()) {
setItemX(position(effectiveRight.item, effectiveRight.anchorLine) - itemPrivate->width() - effectiveRightMargin);
}
} else if (usedAnchors & QDeclarativeAnchors::HCenterAnchor) {
//Handle hCenter
if (effectiveHorizontalCenter.item == item->parentItem()) {
setItemX(adjustedPosition(effectiveHorizontalCenter.item, effectiveHorizontalCenter.anchorLine) - hcenter(item) + effectiveHorizontalCenterOffset);
} else if (effectiveHorizontalCenter.item->parentItem() == item->parentItem()) {
setItemX(position(effectiveHorizontalCenter.item, effectiveHorizontalCenter.anchorLine) - hcenter(item) + effectiveHorizontalCenterOffset);
}
}
--updatingHorizontalAnchor;
} else {
// ### Make this certain :)
qmlInfo(item) << QDeclarativeAnchors::tr("Possible anchor loop detected on horizontal anchor.");
}
}
void QDeclarativeAnchorsPrivate::updateVerticalAnchors()
{
if (fill || centerIn || !isItemComplete())
return;
if (updatingVerticalAnchor < 2) {
++updatingVerticalAnchor;
QGraphicsItemPrivate *itemPrivate = QGraphicsItemPrivate::get(item);
if (usedAnchors & QDeclarativeAnchors::TopAnchor) {
//Handle stretching
bool invalid = true;
qreal height = 0.0;
if (usedAnchors & QDeclarativeAnchors::BottomAnchor) {
invalid = calcStretch(top, bottom, topMargin, -bottomMargin, QDeclarativeAnchorLine::Top, height);
} else if (usedAnchors & QDeclarativeAnchors::VCenterAnchor) {
invalid = calcStretch(top, vCenter, topMargin, vCenterOffset, QDeclarativeAnchorLine::Top, height);
height *= 2;
}
if (!invalid)
setItemHeight(height);
//Handle top
if (top.item == item->parentItem()) {
setItemY(adjustedPosition(top.item, top.anchorLine) + topMargin);
} else if (top.item->parentItem() == item->parentItem()) {
setItemY(position(top.item, top.anchorLine) + topMargin);
}
} else if (usedAnchors & QDeclarativeAnchors::BottomAnchor) {
//Handle stretching (top + bottom case is handled above)
if (usedAnchors & QDeclarativeAnchors::VCenterAnchor) {
qreal height = 0.0;
bool invalid = calcStretch(vCenter, bottom, vCenterOffset, -bottomMargin,
QDeclarativeAnchorLine::Top, height);
if (!invalid)
setItemHeight(height*2);
}
//Handle bottom
if (bottom.item == item->parentItem()) {
setItemY(adjustedPosition(bottom.item, bottom.anchorLine) - itemPrivate->height() - bottomMargin);
} else if (bottom.item->parentItem() == item->parentItem()) {
setItemY(position(bottom.item, bottom.anchorLine) - itemPrivate->height() - bottomMargin);
}
} else if (usedAnchors & QDeclarativeAnchors::VCenterAnchor) {
//(stetching handled above)
//Handle vCenter
if (vCenter.item == item->parentItem()) {
setItemY(adjustedPosition(vCenter.item, vCenter.anchorLine)
- vcenter(item) + vCenterOffset);
} else if (vCenter.item->parentItem() == item->parentItem()) {
setItemY(position(vCenter.item, vCenter.anchorLine) - vcenter(item) + vCenterOffset);
}
} else if (usedAnchors & QDeclarativeAnchors::BaselineAnchor) {
//Handle baseline
if (baseline.item == item->parentItem()) {
if (itemPrivate->isDeclarativeItem)
setItemY(adjustedPosition(baseline.item, baseline.anchorLine)
- static_cast<QDeclarativeItem *>(item)->baselineOffset() + baselineOffset);
} else if (baseline.item->parentItem() == item->parentItem()) {
if (itemPrivate->isDeclarativeItem)
setItemY(position(baseline.item, baseline.anchorLine)
- static_cast<QDeclarativeItem *>(item)->baselineOffset() + baselineOffset);
}
}
--updatingVerticalAnchor;
} else {
// ### Make this certain :)
qmlInfo(item) << QDeclarativeAnchors::tr("Possible anchor loop detected on vertical anchor.");
}
}
void TextureMapperLayer::didCommitScrollOffset(const IntSize& offset)
{
m_userScrollOffset = FloatSize(m_userScrollOffset.width() - offset.width(), m_userScrollOffset.height() - offset.height());
m_currentTransform.setPosition(adjustedPosition());
}
void TextureMapperLayer::setPosition(const FloatPoint& position)
{
m_state.pos = position;
m_currentTransform.setPosition(adjustedPosition());
}
void TextureMapperLayer::flushCompositingStateSelf(GraphicsLayerTextureMapper* graphicsLayer, TextureMapper*)
{
int changeMask = graphicsLayer->changeMask();
if (changeMask == NoChanges && graphicsLayer->m_animations.isEmpty())
return;
graphicsLayer->updateDebugIndicators();
if (changeMask & ParentChange) {
TextureMapperLayer* newParent = toTextureMapperLayer(graphicsLayer->parent());
if (newParent != m_parent) {
// Remove layer from current from child list first.
if (m_parent) {
size_t index = m_parent->m_children.find(this);
m_parent->m_children.remove(index);
m_parent = 0;
}
// Set new layer parent and add layer to the parents child list.
if (newParent) {
m_parent = newParent;
m_parent->m_children.append(this);
}
}
}
if (changeMask & ChildrenChange) {
// Clear children parent pointer to avoid unsync and crash on layer delete.
for (size_t i = 0; i < m_children.size(); i++)
m_children[i]->m_parent = 0;
m_children.clear();
for (size_t i = 0; i < graphicsLayer->children().size(); ++i) {
TextureMapperLayer* child = toTextureMapperLayer(graphicsLayer->children()[i]);
if (!child)
continue;
m_children.append(child);
child->m_parent = this;
}
}
m_size = graphicsLayer->size();
if (changeMask & MaskLayerChange) {
if (TextureMapperLayer* layer = toTextureMapperLayer(graphicsLayer->maskLayer()))
layer->m_effectTarget = this;
}
if (changeMask & ReplicaLayerChange) {
if (TextureMapperLayer* layer = toTextureMapperLayer(graphicsLayer->replicaLayer()))
layer->m_effectTarget = this;
}
if (changeMask & AnimationChange)
m_animations = graphicsLayer->m_animations;
m_state.maskLayer = toTextureMapperLayer(graphicsLayer->maskLayer());
m_state.replicaLayer = toTextureMapperLayer(graphicsLayer->replicaLayer());
m_state.pos = graphicsLayer->position();
m_state.anchorPoint = graphicsLayer->anchorPoint();
m_state.size = graphicsLayer->size();
m_state.contentsRect = graphicsLayer->contentsRect();
m_state.transform = graphicsLayer->transform();
m_state.contentsRect = graphicsLayer->contentsRect();
m_state.preserves3D = graphicsLayer->preserves3D();
m_state.masksToBounds = graphicsLayer->masksToBounds();
m_state.drawsContent = graphicsLayer->drawsContent();
m_state.contentsVisible = graphicsLayer->contentsAreVisible();
m_state.contentsOpaque = graphicsLayer->contentsOpaque();
m_state.backfaceVisibility = graphicsLayer->backfaceVisibility();
m_state.childrenTransform = graphicsLayer->childrenTransform();
m_state.opacity = graphicsLayer->opacity();
#if ENABLE(CSS_FILTERS)
if (changeMask & FilterChange)
m_state.filters = graphicsLayer->filters();
#endif
m_fixedToViewport = graphicsLayer->fixedToViewport();
m_contentsLayer = graphicsLayer->platformLayer();
m_transform.setPosition(adjustedPosition());
m_transform.setAnchorPoint(m_state.anchorPoint);
m_transform.setSize(m_state.size);
m_transform.setFlattening(!m_state.preserves3D);
m_transform.setChildrenTransform(m_state.childrenTransform);
}
