Long live Qt 4.5!

1 files changed, 449 insertions, 0 deletions

diff --git a/src/gui/graphicsview/qgridlayoutengine_p.h b/src/gui/graphicsview/qgridlayoutengine_p.h
new file mode 100644
index 0000000..acc96de
--- /dev/null
+++ b/src/gui/graphicsview/qgridlayoutengine_p.h
@@ -0,0 +1,449 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGRIDLAYOUTENGINE_P_H
+#define QGRIDLAYOUTENGINE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of the graphics view layout classes.  This header
+// file may change from version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qalgorithms.h"
+#include "qbitarray.h"
+#include "qlist.h"
+#include "qmap.h"
+#include "qpair.h"
+#include "qvector.h"
+
+#include <float.h>
+
+QT_BEGIN_NAMESPACE
+
+class QGraphicsLayoutItem;
+class QStyle;
+class QWidget;
+
+// ### deal with Descent in a similar way
+enum {
+    MinimumSize = Qt::MinimumSize,
+    PreferredSize = Qt::PreferredSize,
+    MaximumSize = Qt::MaximumSize,
+    NSizes
+};
+
+// do not reorder
+enum {
+    Hor,
+    Ver,
+    NOrientations
+};
+
+// do not reorder
+enum LayoutSide {
+    Left,
+    Top,
+    Right,
+    Bottom
+};
+
+template <typename T>
+class QLayoutParameter
+{
+public:
+    enum State { Default, User, Cached };
+
+    inline QLayoutParameter() : q_value(T()), q_state(Default) {}
+    inline QLayoutParameter(T value, State state = Default) : q_value(value), q_state(state) {}
+
+    inline void setUserValue(T value) {
+        q_value = value;
+        q_state = User;
+    }
+    inline void setCachedValue(T value) const {
+        if (q_state != User) {
+            q_value = value;
+            q_state = Cached;
+        }
+    }
+    inline T value() const { return q_value; }
+    inline T value(T defaultValue) const { return isUser() ? q_value : defaultValue; }
+    inline bool isDefault() const { return q_state == Default; }
+    inline bool isUser() const { return q_state == User; }
+    inline bool isCached() const { return q_state == Cached; }
+
+private:
+    mutable T q_value;
+    mutable State q_state;
+};
+
+class QStretchParameter : public QLayoutParameter<int>
+{
+public:
+    QStretchParameter() : QLayoutParameter<int>(-1) {}
+
+};
+
+class QLayoutStyleInfo
+{
+public:
+    inline QLayoutStyleInfo() { invalidate(); }
+    inline QLayoutStyleInfo(QStyle *style, QWidget *widget)
+        : q_valid(true), q_style(style), q_widget(widget) {}
+
+    inline void invalidate() { q_valid = false; q_style = 0; q_widget = 0; }
+
+    inline QStyle *style() const { return q_style; }
+    inline QWidget *widget() const { return q_widget; }
+
+    inline bool operator==(const QLayoutStyleInfo &other)
+        { return q_style == other.q_style && q_widget == other.q_widget; }
+    inline bool operator!=(const QLayoutStyleInfo &other)
+        { return !(*this == other); }
+
+private:
+    bool q_valid;
+    QStyle *q_style;
+    QWidget *q_widget;
+};
+
+class QGridLayoutBox
+{
+public:
+    inline QGridLayoutBox()
+        : q_minimumSize(0), q_preferredSize(0), q_maximumSize(FLT_MAX),
+          q_minimumDescent(-1), q_minimumAscent(-1) {}
+
+    void add(const QGridLayoutBox &other, int stretch, qreal spacing);
+    void combine(const QGridLayoutBox &other);
+    void normalize();
+
+#ifdef QT_DEBUG
+    void dump(int indent = 0) const;
+#endif
+    // This code could use the union-struct-array trick, but a compiler
+    // bug prevents this from working.
+    qreal q_minimumSize;
+    qreal q_preferredSize;
+    qreal q_maximumSize;
+    qreal q_minimumDescent;
+    qreal q_minimumAscent;
+    inline qreal &q_sizes(int which)
+    {
+        qreal *t;
+        switch (which) {
+        case Qt::MinimumSize:
+            t = &q_minimumSize;
+            break;
+        case Qt::PreferredSize:
+            t = &q_preferredSize;
+            break;
+        case Qt::MaximumSize:
+            t = &q_maximumSize;
+            break;
+        case Qt::MinimumDescent:
+            t = &q_minimumDescent;
+            break;
+        case (Qt::MinimumDescent + 1):
+            t = &q_minimumAscent;
+            break;
+        default:
+            t = 0;
+            break;
+        }
+        return *t;
+    }
+    inline const qreal &q_sizes(int which) const
+    {
+        const qreal *t;
+        switch (which) {
+        case Qt::MinimumSize:
+            t = &q_minimumSize;
+            break;
+        case Qt::PreferredSize:
+            t = &q_preferredSize;
+            break;
+        case Qt::MaximumSize:
+            t = &q_maximumSize;
+            break;
+        case Qt::MinimumDescent:
+            t = &q_minimumDescent;
+            break;
+        case (Qt::MinimumDescent + 1):
+            t = &q_minimumAscent;
+            break;
+        default:
+            t = 0;
+            break;
+        }
+        return *t;
+    }
+};
+
+bool operator==(const QGridLayoutBox &box1, const QGridLayoutBox &box2);
+inline bool operator!=(const QGridLayoutBox &box1, const QGridLayoutBox &box2)
+    { return !operator==(box1, box2); }
+
+class QGridLayoutMultiCellData
+{
+public:
+    inline QGridLayoutMultiCellData() : q_stretch(-1) {}
+
+    QGridLayoutBox q_box;
+    int q_stretch;
+};
+
+typedef QMap<QPair<int, int>, QGridLayoutMultiCellData> MultiCellMap;
+
+class QGridLayoutRowData
+{
+public:
+    void reset(int count);
+    void distributeMultiCells();
+    void calculateGeometries(int start, int end, qreal targetSize, qreal *positions, qreal *sizes,
+                             qreal *descents, const QGridLayoutBox &totalBox);
+    QGridLayoutBox totalBox(int start, int end) const;
+    void stealBox(int start, int end, int which, qreal *positions, qreal *sizes);
+
+#ifdef QT_DEBUG
+    void dump(int indent = 0) const;
+#endif
+
+    QBitArray ignore;   // ### rename q_
+    QVector<QGridLayoutBox> boxes;
+    MultiCellMap multiCellMap;
+    QVector<int> stretches;
+    QVector<qreal> spacings;
+    bool hasIgnoreFlag;
+};
+
+class QGridLayoutEngine;
+
+class QGridLayoutItem
+{
+public:
+    QGridLayoutItem(QGridLayoutEngine *engine, QGraphicsLayoutItem *layoutItem, int row, int column,
+                    int rowSpan = 1, int columnSpan = 1, Qt::Alignment alignment = 0);
+
+    inline int firstRow() const { return q_firstRows[Ver]; }
+    inline int firstColumn() const { return q_firstRows[Hor]; }
+    inline int rowSpan() const { return q_rowSpans[Ver]; }
+    inline int columnSpan() const { return q_rowSpans[Hor]; }
+    inline int lastRow() const { return firstRow() + rowSpan() - 1; }
+    inline int lastColumn() const { return firstColumn() + columnSpan() - 1; }
+
+    int firstRow(Qt::Orientation orientation) const;
+    int firstColumn(Qt::Orientation orientation) const;
+    int lastRow(Qt::Orientation orientation) const;
+    int lastColumn(Qt::Orientation orientation) const;
+    int rowSpan(Qt::Orientation orientation) const;
+    int columnSpan(Qt::Orientation orientation) const;
+    void setFirstRow(int row, Qt::Orientation orientation = Qt::Vertical);
+    void setRowSpan(int rowSpan, Qt::Orientation orientation = Qt::Vertical);
+
+    int stretchFactor(Qt::Orientation orientation) const;
+    void setStretchFactor(int stretch, Qt::Orientation orientation);
+
+    inline Qt::Alignment alignment() const { return q_alignment; }
+    inline void setAlignment(Qt::Alignment alignment) { q_alignment = alignment; }
+
+    QSizePolicy::Policy sizePolicy(Qt::Orientation orientation) const;
+    QSizePolicy::ControlTypes controlTypes(LayoutSide side) const;
+    QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
+    QGridLayoutBox box(Qt::Orientation orientation, qreal constraint = -1.0) const;
+    QRectF geometryWithin(qreal x, qreal y, qreal width, qreal height, qreal rowDescent) const;
+
+    QGraphicsLayoutItem *layoutItem() const { return q_layoutItem; }
+
+    void setGeometry(const QRectF &rect);
+    void transpose();
+    void insertOrRemoveRows(int row, int delta, Qt::Orientation orientation = Qt::Vertical);
+    QSizeF effectiveMaxSize() const;
+
+#ifdef QT_DEBUG
+    void dump(int indent = 0) const;
+#endif
+
+private:
+    QGridLayoutEngine *q_engine;   // ### needed?
+    QGraphicsLayoutItem *q_layoutItem;
+    int q_firstRows[NOrientations];
+    int q_rowSpans[NOrientations];
+    int q_stretches[NOrientations];
+    Qt::Alignment q_alignment;
+};
+
+class QGridLayoutRowInfo
+{
+public:
+    inline QGridLayoutRowInfo() : count(0) {}
+
+    void insertOrRemoveRows(int row, int delta);
+
+#ifdef QT_DEBUG
+    void dump(int indent = 0) const;
+#endif
+
+    int count;
+    QVector<QStretchParameter> stretches;
+    QVector<QLayoutParameter<qreal> > spacings;
+    QVector<Qt::Alignment> alignments;
+    QVector<QGridLayoutBox> boxes;
+};
+
+class QGridLayoutEngine
+{
+public:
+    QGridLayoutEngine();
+    inline ~QGridLayoutEngine() { qDeleteAll(q_items); }
+
+    int rowCount(Qt::Orientation orientation) const;
+    int columnCount(Qt::Orientation orientation) const;
+    inline int rowCount() const { return q_infos[Ver].count; }
+    inline int columnCount() const { return q_infos[Hor].count; }
+    // returns the number of items inserted, which may be less than (rowCount * columnCount)
+    int itemCount() const;
+    QGridLayoutItem *itemAt(int index) const;
+
+    int effectiveFirstRow(Qt::Orientation orientation = Qt::Vertical) const;
+    int effectiveLastRow(Qt::Orientation orientation = Qt::Vertical) const;
+
+    void setSpacing(qreal spacing, Qt::Orientations orientations);
+    qreal spacing(const QLayoutStyleInfo &styleInfo, Qt::Orientation orientation) const;
+    // ### setSpacingAfterRow(), spacingAfterRow()
+    void setRowSpacing(int row, qreal spacing, Qt::Orientation orientation = Qt::Vertical);
+    qreal rowSpacing(int row, Qt::Orientation orientation = Qt::Vertical) const;
+
+    void setRowStretchFactor(int row, int stretch, Qt::Orientation orientation = Qt::Vertical);
+    int rowStretchFactor(int row, Qt::Orientation orientation = Qt::Vertical) const;
+
+    void setStretchFactor(QGraphicsLayoutItem *layoutItem, int stretch,
+                          Qt::Orientation orientation);
+    int stretchFactor(QGraphicsLayoutItem *layoutItem, Qt::Orientation orientation) const;
+
+    void setRowSizeHint(Qt::SizeHint which, int row, qreal size,
+                        Qt::Orientation orientation = Qt::Vertical);
+    qreal rowSizeHint(Qt::SizeHint which, int row,
+                      Qt::Orientation orientation = Qt::Vertical) const;
+
+    void setRowAlignment(int row, Qt::Alignment alignment, Qt::Orientation orientation);
+    Qt::Alignment rowAlignment(int row, Qt::Orientation orientation) const;
+
+    void setAlignment(QGraphicsLayoutItem *layoutItem, Qt::Alignment alignment);
+    Qt::Alignment alignment(QGraphicsLayoutItem *layoutItem) const;
+    Qt::Alignment effectiveAlignment(const QGridLayoutItem *layoutItem) const;
+
+
+    void addItem(QGridLayoutItem *item);
+    void removeItem(QGridLayoutItem *item);
+    QGridLayoutItem *findLayoutItem(QGraphicsLayoutItem *layoutItem) const;
+    QGridLayoutItem *itemAt(int row, int column, Qt::Orientation orientation = Qt::Vertical) const;
+    inline void insertRow(int row, Qt::Orientation orientation = Qt::Vertical)
+        { insertOrRemoveRows(row, +1, orientation); }
+    inline void removeRow(int row, Qt::Orientation orientation = Qt::Vertical)
+        { insertOrRemoveRows(row, -1, orientation); }
+
+    void invalidate();
+    void setGeometries(const QLayoutStyleInfo &styleInfo, const QRectF &contentsGeometry);
+    QRectF cellRect(const QLayoutStyleInfo &styleInfo, const QRectF &contentsGeometry, int row,
+                    int column, int rowSpan, int columnSpan) const;
+    QSizeF sizeHint(const QLayoutStyleInfo &styleInfo, Qt::SizeHint which,
+                    const QSizeF &constraint) const;
+    QSizePolicy::ControlTypes controlTypes(LayoutSide side) const;
+    void transpose();
+    void setVisualDirection(Qt::LayoutDirection direction);
+    Qt::LayoutDirection visualDirection() const;
+#ifdef QT_DEBUG
+    void dump(int indent = 0) const;
+#endif
+
+private:
+    static int grossRoundUp(int n) { return ((n + 2) | 0x3) - 2; }
+
+    void maybeExpandGrid(int row, int column, Qt::Orientation orientation = Qt::Vertical);
+    void regenerateGrid();
+    inline int internalGridRowCount() const { return grossRoundUp(rowCount()); }
+    inline int internalGridColumnCount() const { return grossRoundUp(columnCount()); }
+    void setItemAt(int row, int column, QGridLayoutItem *item);
+    void insertOrRemoveRows(int row, int delta, Qt::Orientation orientation = Qt::Vertical);
+    void fillRowData(QGridLayoutRowData *rowData, const QLayoutStyleInfo &styleInfo,
+                     Qt::Orientation orientation = Qt::Vertical) const;
+    void ensureEffectiveFirstAndLastRows() const;
+    void ensureColumnAndRowData(const QLayoutStyleInfo &styleInfo) const;
+    void ensureGeometries(const QLayoutStyleInfo &styleInfo, const QSizeF &size) const;
+
+    // User input
+    QVector<QGridLayoutItem *> q_grid;
+    QList<QGridLayoutItem *> q_items;
+    QLayoutParameter<qreal> q_defaultSpacings[NOrientations];
+    QGridLayoutRowInfo q_infos[NOrientations];
+    Qt::LayoutDirection m_visualDirection;
+
+    // Lazily computed from the above user input
+    mutable int q_cachedEffectiveFirstRows[NOrientations];
+    mutable int q_cachedEffectiveLastRows[NOrientations];
+
+    // Layout item input
+    mutable QLayoutStyleInfo q_cachedDataForStyleInfo;
+    mutable QGridLayoutRowData q_columnData;
+    mutable QGridLayoutRowData q_rowData;
+    mutable QGridLayoutBox q_totalBoxes[NOrientations];
+
+    // Output
+    mutable QSizeF q_cachedSize;
+    mutable QVector<qreal> q_xx;
+    mutable QVector<qreal> q_yy;
+    mutable QVector<qreal> q_widths;
+    mutable QVector<qreal> q_heights;
+    mutable QVector<qreal> q_descents;
+
+    friend class QGridLayoutItem;
+};
+
+QT_END_NAMESPACE
+
+#endif