Fill out QGraphicsLayout bindings

The QGraphicsLayout API is too imperative for good bindings, but now it
is at least possible to initialize values in QML.

Task-number: QTBUG-5760

2 files changed, 187 insertions, 3 deletions

diff --git a/src/imports/widgets/graphicslayouts.cpp b/src/imports/widgets/graphicslayouts.cpp
index fc15ad2..25cf994 100644
--- a/src/imports/widgets/graphicslayouts.cpp
+++ b/src/imports/widgets/graphicslayouts.cpp
@@ -47,7 +47,7 @@
 QT_BEGIN_NAMESPACE
 
 LinearLayoutAttached::LinearLayoutAttached(QObject *parent)
-: QObject(parent), _stretch(1), _alignment(Qt::AlignCenter)
+: QObject(parent), _stretch(1), _alignment(Qt::AlignCenter), _spacing(0)
 {
 }
 
@@ -60,6 +60,15 @@ void LinearLayoutAttached::setStretchFactor(int f)
     emit stretchChanged(reinterpret_cast<QGraphicsLayoutItem*>(parent()), _stretch);
 }
 
+void LinearLayoutAttached::setSpacing(int s)
+{
+    if (_spacing == s)
+        return;
+
+    _spacing = s;
+    emit spacingChanged(reinterpret_cast<QGraphicsLayoutItem*>(parent()), _spacing);
+}
+
 void LinearLayoutAttached::setAlignment(Qt::Alignment a)
 {
     if (_alignment == a)
@@ -99,10 +108,13 @@ insertItem(index, item);
 if (LinearLayoutAttached *obj = attachedProperties.value(item)) {
     setStretchFactor(item, obj->stretchFactor());
     setAlignment(item, obj->alignment());
+    updateSpacing(item, obj->spacing());
     QObject::connect(obj, SIGNAL(stretchChanged(QGraphicsLayoutItem*,int)),
                      this, SLOT(updateStretch(QGraphicsLayoutItem*,int)));
     QObject::connect(obj, SIGNAL(alignmentChanged(QGraphicsLayoutItem*,Qt::Alignment)),
                      this, SLOT(updateAlignment(QGraphicsLayoutItem*,Qt::Alignment)));
+    QObject::connect(obj, SIGNAL(spacingChanged(QGraphicsLayoutItem*,int)),
+                     this, SLOT(updateSpacing(QGraphicsLayoutItem*,int)));
     //### need to disconnect when widget is removed?
 }
 }
@@ -114,11 +126,35 @@ for (int i = 0; i < count(); ++i)
     removeAt(i);
 }
 
+qreal QGraphicsLinearLayoutObject::contentsMargin() const
+{
+    qreal a,b,c,d;
+    getContentsMargins(&a, &b, &c, &d);
+    if(a==b && a==c && a==d)
+        return a;
+    return -1;
+}
+
+void QGraphicsLinearLayoutObject::setContentsMargin(qreal m)
+{
+    setContentsMargins(m,m,m,m);
+}
+
 void QGraphicsLinearLayoutObject::updateStretch(QGraphicsLayoutItem *item, int stretch)
 {
 QGraphicsLinearLayout::setStretchFactor(item, stretch);
 }
 
+void QGraphicsLinearLayoutObject::updateSpacing(QGraphicsLayoutItem* item, int spacing)
+{
+    for(int i=0; i < count(); i++){
+        if(itemAt(i) == item){ //I do not see the reverse function, which is why we must loop over all items
+            QGraphicsLinearLayout::setItemSpacing(i, spacing);
+            return;
+        }
+    }
+}
+
 void QGraphicsLinearLayoutObject::updateAlignment(QGraphicsLayoutItem *item, Qt::Alignment alignment)
 {
 QGraphicsLinearLayout::setAlignment(item, alignment);
@@ -139,7 +175,9 @@ return rv;
 // QGraphicsGridLayout-related classes
 //////////////////////////////////////////////////////////////////////////////////////////////////////
 GridLayoutAttached::GridLayoutAttached(QObject *parent)
-: QObject(parent), _row(-1), _column(-1), _rowspan(1), _colspan(1), _alignment(-1)
+: QObject(parent), _row(-1), _column(-1), _rowspan(1), _colspan(1), _alignment(-1), _rowstretch(-1),
+    _colstretch(-1), _rowspacing(-1), _colspacing(-1), _rowprefheight(-1), _rowmaxheight(-1), _rowminheight(-1),
+    _rowfixheight(-1), _colprefwidth(-1), _colmaxwidth(-1), _colminwidth(-1), _colfixwidth(-1)
 {
 }
 
@@ -185,9 +223,30 @@ void GridLayoutAttached::setAlignment(Qt::Alignment a)
         return;
 
     _alignment = a;
-    //emit alignmentChanged(reinterpret_cast<QGraphicsLayoutItem*>(parent()), _alignment);
+    emit alignmentChanged(reinterpret_cast<QGraphicsLayoutItem*>(parent()), _alignment);
+}
+
+void GridLayoutAttached::setRowStretchFactor(int f)
+{
+    _rowstretch = f;
+}
+
+void GridLayoutAttached::setColumnStretchFactor(int f)
+{
+    _colstretch = f;
+}
+
+void GridLayoutAttached::setRowSpacing(int s)
+{
+    _rowspacing = s;
 }
 
+void GridLayoutAttached::setColumnSpacing(int s)
+{
+    _colspacing = s;
+}
+
+
 QGraphicsGridLayoutObject::QGraphicsGridLayoutObject(QObject *parent)
 : QObject(parent)
 {
@@ -226,9 +285,36 @@ if (GridLayoutAttached *obj = attachedProperties.value(item)) {
         qWarning() << "Must set row and column for an item in a grid layout";
         return;
     }
+    if(obj->rowSpacing() != -1)
+        setRowSpacing(row, obj->rowSpacing());
+    if(obj->columnSpacing() != -1)
+        setColumnSpacing(column, obj->columnSpacing());
+    if(obj->rowStretchFactor() != -1)
+        setRowStretchFactor(row, obj->rowStretchFactor());
+    if(obj->columnStretchFactor() != -1)
+        setColumnStretchFactor(column, obj->columnStretchFactor());
+    if(obj->rowPreferredHeight() != -1)
+        setRowPreferredHeight(row, obj->rowPreferredHeight());
+    if(obj->rowMaximumHeight() != -1)
+        setRowMaximumHeight(row, obj->rowMaximumHeight());
+    if(obj->rowMinimumHeight() != -1)
+        setRowMinimumHeight(row, obj->rowMinimumHeight());
+    if(obj->rowFixedHeight() != -1)
+        setRowFixedHeight(row, obj->rowFixedHeight());
+    if(obj->columnPreferredWidth() != -1)
+        setColumnPreferredWidth(row, obj->columnPreferredWidth());
+    if(obj->columnMaximumWidth() != -1)
+        setColumnMaximumWidth(row, obj->columnMaximumWidth());
+    if(obj->columnMinimumWidth() != -1)
+        setColumnMinimumWidth(row, obj->columnMinimumWidth());
+    if(obj->columnFixedWidth() != -1)
+        setColumnFixedWidth(row, obj->columnFixedWidth());
     addItem(item, row, column, rowSpan, columnSpan);
     if (alignment != -1)
         setAlignment(item,alignment);
+    QObject::connect(obj, SIGNAL(alignmentChanged(QGraphicsLayoutItem*,Qt::Alignment)),
+                     this, SLOT(updateAlignment(QGraphicsLayoutItem*,Qt::Alignment)));
+    //### need to disconnect when widget is removed?
 }
 }
 
@@ -246,6 +332,26 @@ if (verticalSpacing() == horizontalSpacing())
 return -1;  //###
 }
 
+qreal QGraphicsGridLayoutObject::contentsMargin() const
+{
+    qreal a,b,c,d;
+    getContentsMargins(&a, &b, &c, &d);
+    if(a==b && a==c && a==d)
+        return a;
+    return -1;
+}
+
+void QGraphicsGridLayoutObject::setContentsMargin(qreal m)
+{
+    setContentsMargins(m,m,m,m);
+}
+
+
+void QGraphicsGridLayoutObject::updateAlignment(QGraphicsLayoutItem *item, Qt::Alignment alignment)
+{
+QGraphicsGridLayout::setAlignment(item, alignment);
+}
+
 QHash<QGraphicsLayoutItem*, GridLayoutAttached*> QGraphicsGridLayoutObject::attachedProperties;
 GridLayoutAttached *QGraphicsGridLayoutObject::qmlAttachedProperties(QObject *obj)
 {
diff --git a/src/imports/widgets/graphicslayouts_p.h b/src/imports/widgets/graphicslayouts_p.h
index 1c3dfe5..ea9c614 100644
--- a/src/imports/widgets/graphicslayouts_p.h
+++ b/src/imports/widgets/graphicslayouts_p.h
@@ -71,6 +71,7 @@ class QGraphicsLinearLayoutObject : public QObject, public QGraphicsLinearLayout
     Q_PROPERTY(QDeclarativeListProperty<QGraphicsLayoutItem> children READ children)
     Q_PROPERTY(Qt::Orientation orientation READ orientation WRITE setOrientation)
     Q_PROPERTY(qreal spacing READ spacing WRITE setSpacing)
+    Q_PROPERTY(qreal contentsMargin READ contentsMargin WRITE setContentsMargin)
     Q_CLASSINFO("DefaultProperty", "children")
 public:
     QGraphicsLinearLayoutObject(QObject * = 0);
@@ -80,8 +81,12 @@ public:
 
     static LinearLayoutAttached *qmlAttachedProperties(QObject *);
 
+    qreal contentsMargin() const;
+    void setContentsMargin(qreal);
+
 private Q_SLOTS:
     void updateStretch(QGraphicsLayoutItem*,int);
+    void updateSpacing(QGraphicsLayoutItem*,int);
     void updateAlignment(QGraphicsLayoutItem*,Qt::Alignment);
 
 private:
@@ -115,6 +120,7 @@ class QGraphicsGridLayoutObject : public QObject, public QGraphicsGridLayout
 
     Q_PROPERTY(QDeclarativeListProperty<QGraphicsLayoutItem> children READ children)
     Q_PROPERTY(qreal spacing READ spacing WRITE setSpacing)
+    Q_PROPERTY(qreal contentsMargin READ contentsMargin WRITE setContentsMargin)
     Q_PROPERTY(qreal verticalSpacing READ verticalSpacing WRITE setVerticalSpacing)
     Q_PROPERTY(qreal horizontalSpacing READ horizontalSpacing WRITE setHorizontalSpacing)
     Q_CLASSINFO("DefaultProperty", "children")
@@ -125,9 +131,14 @@ public:
     QDeclarativeListProperty<QGraphicsLayoutItem> children() { return QDeclarativeListProperty<QGraphicsLayoutItem>(this, 0, children_append, children_count, children_at, children_clear); }
 
     qreal spacing() const;
+    qreal contentsMargin() const;
+    void setContentsMargin(qreal);
 
     static GridLayoutAttached *qmlAttachedProperties(QObject *);
 
+private Q_SLOTS:
+    void updateAlignment(QGraphicsLayoutItem*,Qt::Alignment);
+
 private:
     friend class GraphicsLayoutAttached;
     void addWidget(QGraphicsWidget *);
@@ -158,6 +169,7 @@ class LinearLayoutAttached : public QObject
 
     Q_PROPERTY(int stretchFactor READ stretchFactor WRITE setStretchFactor NOTIFY stretchChanged)
     Q_PROPERTY(Qt::Alignment alignment READ alignment WRITE setAlignment NOTIFY alignmentChanged)
+    Q_PROPERTY(int spacing READ spacing WRITE setSpacing NOTIFY spacingChanged)
 public:
     LinearLayoutAttached(QObject *parent);
 
@@ -165,14 +177,18 @@ public:
     void setStretchFactor(int f);
     Qt::Alignment alignment() const { return _alignment; }
     void setAlignment(Qt::Alignment a);
+    int spacing() const { return _spacing; }
+    void setSpacing(int s);
 
 Q_SIGNALS:
     void stretchChanged(QGraphicsLayoutItem*,int);
     void alignmentChanged(QGraphicsLayoutItem*,Qt::Alignment);
+    void spacingChanged(QGraphicsLayoutItem*,int);
 
 private:
     int _stretch;
     Qt::Alignment _alignment;
+    int _spacing;
 };
 
 class GridLayoutAttached : public QObject
@@ -184,6 +200,19 @@ class GridLayoutAttached : public QObject
     Q_PROPERTY(int rowSpan READ rowSpan WRITE setRowSpan)
     Q_PROPERTY(int columnSpan READ columnSpan WRITE setColumnSpan)
     Q_PROPERTY(Qt::Alignment alignment READ alignment WRITE setAlignment)
+    Q_PROPERTY(int rowStretchFactor READ rowStretchFactor WRITE setRowStretchFactor)
+    Q_PROPERTY(int columnStretchFactor READ columnStretchFactor WRITE setColumnStretchFactor)
+    Q_PROPERTY(int rowSpacing READ rowSpacing WRITE setRowSpacing)
+    Q_PROPERTY(int columnSpacing READ columnSpacing WRITE setColumnSpacing)
+    Q_PROPERTY(int rowPreferredHeight READ rowPreferredHeight WRITE setRowPreferredHeight)
+    Q_PROPERTY(int rowMinimumHeight READ rowMinimumHeight WRITE setRowMinimumHeight)
+    Q_PROPERTY(int rowMaximumHeight READ rowMaximumHeight WRITE setRowMaximumHeight)
+    Q_PROPERTY(int rowFixedHeight READ rowFixedHeight WRITE setRowFixedHeight)
+    Q_PROPERTY(int columnPreferredWidth READ columnPreferredWidth WRITE setColumnPreferredWidth)
+    Q_PROPERTY(int columnMaximumWidth READ columnMaximumWidth WRITE setColumnMaximumWidth)
+    Q_PROPERTY(int columnMinimumWidth READ columnMinimumWidth WRITE setColumnMinimumWidth)
+    Q_PROPERTY(int columnFixedWidth READ columnFixedWidth WRITE setColumnFixedWidth)
+
 public:
     GridLayoutAttached(QObject *parent);
 
@@ -202,12 +231,61 @@ public:
     Qt::Alignment alignment() const { return _alignment; }
     void setAlignment(Qt::Alignment a);
 
+    int rowStretchFactor() const { return _rowstretch; }
+    void setRowStretchFactor(int f);
+    int columnStretchFactor() const { return _colstretch; }
+    void setColumnStretchFactor(int f);
+
+    int rowSpacing() const { return _rowspacing; }
+    void setRowSpacing(int s);
+    int columnSpacing() const { return _colspacing; }
+    void setColumnSpacing(int s);
+
+    int rowPreferredHeight() const { return _rowprefheight; }
+    void setRowPreferredHeight(int s) { _rowprefheight = s; }
+
+    int rowMaximumHeight() const { return _rowmaxheight; }
+    void setRowMaximumHeight(int s) { _rowmaxheight = s; }
+
+    int rowMinimumHeight() const { return _rowminheight; }
+    void setRowMinimumHeight(int s) { _rowminheight = s; }
+
+    int rowFixedHeight() const { return _rowfixheight; }
+    void setRowFixedHeight(int s) { _rowfixheight = s; }
+
+    int columnPreferredWidth() const { return _colprefwidth; }
+    void setColumnPreferredWidth(int s) { _colprefwidth = s; }
+
+    int columnMaximumWidth() const { return _colmaxwidth; }
+    void setColumnMaximumWidth(int s) { _colmaxwidth = s; }
+
+    int columnMinimumWidth() const { return _colminwidth; }
+    void setColumnMinimumWidth(int s) { _colminwidth = s; }
+
+    int columnFixedWidth() const { return _colfixwidth; }
+    void setColumnFixedWidth(int s) { _colfixwidth = s; }
+
+Q_SIGNALS:
+    void alignmentChanged(QGraphicsLayoutItem*,Qt::Alignment);
+
 private:
     int _row;
     int _column;
     int _rowspan;
     int _colspan;
     Qt::Alignment _alignment;
+    int _rowstretch;
+    int _colstretch;
+    int _rowspacing;
+    int _colspacing;
+    int _rowprefheight;
+    int _rowmaxheight;
+    int _rowminheight;
+    int _rowfixheight;
+    int _colprefwidth;
+    int _colmaxwidth;
+    int _colminwidth;
+    int _colfixwidth;
 };
 
 QT_END_NAMESPACE