Add support for anchor mirroring

Task-number: QTBUG-15879
Reviewed-by: Michael Brasser
Change-Id: I833132153ba95437a86bb840a96d5507612d3fa8

3 files changed, 96 insertions, 25 deletions

diff --git a/src/declarative/graphicsitems/qdeclarativeanchors.cpp b/src/declarative/graphicsitems/qdeclarativeanchors.cpp
index 444bbd4..a2d6261 100644
--- a/src/declarative/graphicsitems/qdeclarativeanchors.cpp
+++ b/src/declarative/graphicsitems/qdeclarativeanchors.cpp
@@ -181,10 +181,12 @@ void QDeclarativeAnchorsPrivate::fillChanged()
     if (updatingFill < 2) {
         ++updatingFill;
 
+        qreal horizontalMargin = isMirrored() ? rightMargin : leftMargin;
+
         if (fill == item->parentItem()) {                         //child-parent
-            setItemPos(QPointF(leftMargin, topMargin));
+            setItemPos(QPointF(horizontalMargin, topMargin));
         } else if (fill->parentItem() == item->parentItem()) {   //siblings
-            setItemPos(QPointF(fill->x()+leftMargin, fill->y()+topMargin));
+            setItemPos(QPointF(fill->x()+horizontalMargin, fill->y()+topMargin));
         }
         QGraphicsItemPrivate *fillPrivate = QGraphicsItemPrivate::get(fill);
         setItemSize(QSizeF(fillPrivate->width()-leftMargin-rightMargin, fillPrivate->height()-topMargin-bottomMargin));
@@ -204,13 +206,15 @@ void QDeclarativeAnchorsPrivate::centerInChanged()
 
     if (updatingCenterIn < 2) {
         ++updatingCenterIn;
+
+        qreal effectiveHCenterOffset = isMirrored() ? -hCenterOffset : hCenterOffset;
         if (centerIn == item->parentItem()) {
-            QPointF p(hcenter(item->parentItem()) - hcenter(item) + hCenterOffset,
+            QPointF p(hcenter(item->parentItem()) - hcenter(item) + effectiveHCenterOffset,
                       vcenter(item->parentItem()) - vcenter(item) + vCenterOffset);
             setItemPos(p);
 
         } else if (centerIn->parentItem() == item->parentItem()) {
-            QPointF p(centerIn->x() + hcenter(centerIn) - hcenter(item) + hCenterOffset,
+            QPointF p(centerIn->x() + hcenter(centerIn) - hcenter(item) + effectiveHCenterOffset,
                       centerIn->y() + vcenter(centerIn) - vcenter(item) + vCenterOffset);
             setItemPos(p);
         }
@@ -498,6 +502,11 @@ bool QDeclarativeAnchorsPrivate::calcStretch(const QDeclarativeAnchorLine &edge1
     return invalid;
 }
 
+bool QDeclarativeAnchorsPrivate::isMirrored() const
+{
+    return layoutDirection == Qt::RightToLeft;
+}
+
 void QDeclarativeAnchorsPrivate::updateVerticalAnchors()
 {
     if (fill || centerIn || !isItemComplete())
@@ -570,58 +579,93 @@ void QDeclarativeAnchorsPrivate::updateVerticalAnchors()
     }
 }
 
+inline QDeclarativeAnchorLine::AnchorLine reverseAnchorLine(QDeclarativeAnchorLine::AnchorLine anchorLine) {
+    if (anchorLine == QDeclarativeAnchorLine::Left) {
+        return QDeclarativeAnchorLine::Right;
+    } else if (anchorLine == QDeclarativeAnchorLine::Right) {
+        return QDeclarativeAnchorLine::Left;
+    } else {
+        return anchorLine;
+    }
+}
+
 void QDeclarativeAnchorsPrivate::updateHorizontalAnchors()
 {
     if (fill || centerIn || !isItemComplete())
         return;
 
-    if (updatingHorizontalAnchor < 2) {
+    if (updatingHorizontalAnchor < 3) {
         ++updatingHorizontalAnchor;
+        qreal effectiveRightMargin, effectiveLeftMargin, effectiveHorizontalCenterOffset;
+        QDeclarativeAnchorLine effectiveLeft, effectiveRight, effectiveHorizontalCenter;
+        QDeclarativeAnchors::Anchor effectiveLeftAnchor, effectiveRightAnchor;
+        if (isMirrored()) {
+            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 & QDeclarativeAnchors::LeftAnchor) {
+        if (usedAnchors & effectiveLeftAnchor) {
             //Handle stretching
             bool invalid = true;
             qreal width = 0.0;
-            if (usedAnchors & QDeclarativeAnchors::RightAnchor) {
-                invalid = calcStretch(left, right, leftMargin, -rightMargin, QDeclarativeAnchorLine::Left, width);
+            if (usedAnchors & effectiveRightAnchor) {
+                invalid = calcStretch(effectiveLeft, effectiveRight, effectiveLeftMargin, -effectiveRightMargin, QDeclarativeAnchorLine::Left, width);
             } else if (usedAnchors & QDeclarativeAnchors::HCenterAnchor) {
-                invalid = calcStretch(left, hCenter, leftMargin, hCenterOffset, QDeclarativeAnchorLine::Left, width);
+                invalid = calcStretch(effectiveLeft, effectiveHorizontalCenter, effectiveLeftMargin, effectiveHorizontalCenterOffset, 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);
+            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 & QDeclarativeAnchors::RightAnchor) {
+        } else if (usedAnchors & effectiveRightAnchor) {
             //Handle stretching (left + right case is handled in updateLeftAnchor)
             if (usedAnchors & QDeclarativeAnchors::HCenterAnchor) {
                 qreal width = 0.0;
-                bool invalid = calcStretch(hCenter, right, hCenterOffset, -rightMargin,
+                bool invalid = calcStretch(effectiveHorizontalCenter, effectiveRight, effectiveHorizontalCenterOffset, -effectiveRightMargin,
                                               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);
+            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 (hCenter.item == item->parentItem()) {
-                setItemX(adjustedPosition(hCenter.item, hCenter.anchorLine) - hcenter(item) + hCenterOffset);
-            } else if (hCenter.item->parentItem() == item->parentItem()) {
-                setItemX(position(hCenter.item, hCenter.anchorLine) - hcenter(item) + hCenterOffset);
+            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 :)
@@ -1042,6 +1086,25 @@ QDeclarativeAnchors::Anchors QDeclarativeAnchors::usedAnchors() const
     return d->usedAnchors;
 }
 
+
+Qt::LayoutDirection QDeclarativeAnchors::layoutDirection() const
+{
+    Q_D(const QDeclarativeAnchors);
+    return d->layoutDirection;
+}
+
+void QDeclarativeAnchors::setLayoutDirection(Qt::LayoutDirection layoutDirection)
+{
+    Q_D(QDeclarativeAnchors);
+    if (d->layoutDirection != layoutDirection) {
+        d->layoutDirection = layoutDirection;
+        d->fillChanged();
+        d->centerInChanged();
+        d->updateHorizontalAnchors();
+        emit layoutDirectionChanged();
+    }
+}
+
 bool QDeclarativeAnchorsPrivate::checkHValid() const
 {
     if (usedAnchors & QDeclarativeAnchors::LeftAnchor &&
diff --git a/src/declarative/graphicsitems/qdeclarativeanchors_p.h b/src/declarative/graphicsitems/qdeclarativeanchors_p.h
index d2c0a89..90a3508 100644
--- a/src/declarative/graphicsitems/qdeclarativeanchors_p.h
+++ b/src/declarative/graphicsitems/qdeclarativeanchors_p.h
@@ -79,6 +79,7 @@ class Q_DECLARATIVE_PRIVATE_EXPORT QDeclarativeAnchors : public QObject
     Q_PROPERTY(qreal baselineOffset READ baselineOffset WRITE setBaselineOffset NOTIFY baselineOffsetChanged)
     Q_PROPERTY(QGraphicsObject *fill READ fill WRITE setFill RESET resetFill NOTIFY fillChanged)
     Q_PROPERTY(QGraphicsObject *centerIn READ centerIn WRITE setCenterIn RESET resetCenterIn NOTIFY centerInChanged)
+    Q_PROPERTY(Qt::LayoutDirection layoutDirection READ layoutDirection WRITE setLayoutDirection NOTIFY layoutDirectionChanged REVISION 1)
 
 public:
     QDeclarativeAnchors(QObject *parent=0);
@@ -160,6 +161,9 @@ public:
 
     Anchors usedAnchors() const;
 
+    Qt::LayoutDirection layoutDirection() const;
+    void setLayoutDirection (Qt::LayoutDirection);
+
     void classBegin();
     void componentComplete();
 
@@ -181,6 +185,7 @@ Q_SIGNALS:
     void verticalCenterOffsetChanged();
     void horizontalCenterOffsetChanged();
     void baselineOffsetChanged();
+    Q_REVISION(1) void layoutDirectionChanged();
 
 private:
     friend class QDeclarativeItem;
diff --git a/src/declarative/graphicsitems/qdeclarativeanchors_p_p.h b/src/declarative/graphicsitems/qdeclarativeanchors_p_p.h
index c4508e0..ec96582 100644
--- a/src/declarative/graphicsitems/qdeclarativeanchors_p_p.h
+++ b/src/declarative/graphicsitems/qdeclarativeanchors_p_p.h
@@ -94,7 +94,7 @@ public:
       : componentComplete(true), updatingMe(false), updatingHorizontalAnchor(0),
         updatingVerticalAnchor(0), updatingFill(0), updatingCenterIn(0), item(i), usedAnchors(0), fill(0),
         centerIn(0), leftMargin(0), rightMargin(0), topMargin(0), bottomMargin(0),
-        margins(0), vCenterOffset(0), hCenterOffset(0), baselineOffset(0)
+        margins(0), vCenterOffset(0), hCenterOffset(0), baselineOffset(0), layoutDirection(Qt::LeftToRight)
     {
     }
 
@@ -133,6 +133,7 @@ public:
     bool checkVAnchorValid(QDeclarativeAnchorLine anchor) const;
     bool calcStretch(const QDeclarativeAnchorLine &edge1, const QDeclarativeAnchorLine &edge2, qreal offset1, qreal offset2, QDeclarativeAnchorLine::AnchorLine line, qreal &stretch);
 
+    bool isMirrored() const;
     void updateHorizontalAnchors();
     void updateVerticalAnchors();
     void fillChanged();
@@ -160,6 +161,8 @@ public:
     qreal vCenterOffset;
     qreal hCenterOffset;
     qreal baselineOffset;
+
+    Qt::LayoutDirection layoutDirection;
 };
 
 QT_END_NAMESPACE