/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (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 Technology Preview License Agreement accompanying

** this package.

**

** 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.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qapplication.h"

#include "qdebug.h"

#include "qformlayout.h"

#include "qlabel.h"

#include "qlayout_p.h"

#include "qlayoutengine_p.h"

#include "qrect.h"

#include "qvector.h"

#include "qwidget.h"

QT_BEGIN_NAMESPACE

namespace {

// Fixed column matrix, stores items as [i11, i12, i21, i22...],

// with FORTRAN-style index operator(r, c).

template <class T, int NumColumns>

class FixedColumnMatrix {

public:

    typedef QVector<T> Storage;

    FixedColumnMatrix() { }

    void clear() { m_storage.clear(); }

    const T &operator()(int r, int c) const { return m_storage[r * NumColumns + c]; }

    T &operator()(int r, int c) { return m_storage[r * NumColumns + c]; }

    int rowCount() const { return m_storage.size() / NumColumns; }

    void addRow(const T &value);

    void insertRow(int r, const T &value);

    void removeRow(int r);

    bool find(const T &value, int *rowPtr, int *colPtr) const ;

    int count(const T &value) const { return m_storage.count(value);  }

    // Hmmpf.. Some things are faster that way.

    const Storage &storage() const { return m_storage; }

    static void storageIndexToPosition(int idx, int *rowPtr, int *colPtr);

private:

    Storage m_storage;

};

template <class T, int NumColumns>

void FixedColumnMatrix<T, NumColumns>::addRow(const T &value)

{

    for (int i = 0; i < NumColumns; ++i)

        m_storage.append(value);

}

template <class T, int NumColumns>

void FixedColumnMatrix<T, NumColumns>::insertRow(int r, const T &value)

{

    Q_TYPENAME Storage::iterator it = m_storage.begin();

    it += r * NumColumns;

    m_storage.insert(it, NumColumns, value);

}

template <class T, int NumColumns>

void FixedColumnMatrix<T, NumColumns>::removeRow(int r)

{

    m_storage.remove(r * NumColumns, NumColumns);

}

template <class T, int NumColumns>

bool FixedColumnMatrix<T, NumColumns>::find(const T &value, int *rowPtr, int *colPtr) const

{

    const int idx = m_storage.indexOf(value);

    if (idx == -1)

        return false;

    storageIndexToPosition(idx, rowPtr, colPtr);

    return true;

}

template <class T, int NumColumns>

void FixedColumnMatrix<T, NumColumns>::storageIndexToPosition(int idx, int *rowPtr, int *colPtr)

{

    *rowPtr = idx / NumColumns;

    *colPtr = idx % NumColumns;

}

} // namespace

// special values for unset fields; must not clash with values of FieldGrowthPolicy or

// RowWrapPolicy

const uint DefaultFieldGrowthPolicy = 255;

const uint DefaultRowWrapPolicy = 255;

enum { ColumnCount = 2 };

// -- our data structure for our items

// This owns the QLayoutItem

struct QFormLayoutItem

{

    QFormLayoutItem(QLayoutItem* i) : item(i), fullRow(false), isHfw(false) { }

    ~QFormLayoutItem() { delete item; }

    // Wrappers

    QWidget *widget() const { return item->widget(); }

    QLayout *layout() const { return item->layout(); }

    bool hasHeightForWidth() const { return item->hasHeightForWidth(); }

    int heightForWidth(int width) const { return item->heightForWidth(width); }

    int minimumHeightForWidth(int width) const { return item->minimumHeightForWidth(width); }

    Qt::Orientations expandingDirections() const { return item->expandingDirections(); }

    QSizePolicy::ControlTypes controlTypes() const { return item->controlTypes(); }

    int vStretch() const { return widget() ? widget()->sizePolicy().verticalStretch() : 0; }

    void setGeometry(const QRect& r) { item->setGeometry(r); }

    QRect geometry() const { return item->geometry(); }

    // For use with FixedColumnMatrix

    bool operator==(const QFormLayoutItem& other) { return item == other.item; }

    QLayoutItem *item;

    bool fullRow;

    // set by updateSizes

    bool isHfw;

    QSize minSize;

    QSize sizeHint;

    QSize maxSize;

    // also set by updateSizes

    int sbsHSpace; // only used for side by side, for the field item only (not label)

    int vSpace; // This is the spacing to the item in the row above

    // set by setupVerticalLayoutData

    bool sideBySide;

    int vLayoutIndex;

    // set by setupHorizontalLayoutData

    int layoutPos;

    int layoutWidth;

};

class QFormLayoutPrivate : public QLayoutPrivate

{

    Q_DECLARE_PUBLIC(QFormLayout)

public:

    typedef FixedColumnMatrix<QFormLayoutItem *, ColumnCount> ItemMatrix;

    QFormLayoutPrivate();

    ~QFormLayoutPrivate() { }

    int insertRow(int row);

    void insertRows(int row, int count);

    void setItem(int row, QFormLayout::ItemRole role, QLayoutItem *item);

    void setLayout(int row, QFormLayout::ItemRole role, QLayout *layout);

    void setWidget(int row, QFormLayout::ItemRole role, QWidget *widget);

    void arrangeWidgets(const QVector<QLayoutStruct>& layouts, QRect &rect);

    void updateSizes();

    void setupVerticalLayoutData(int width);

    void setupHorizontalLayoutData(int width);

    QStyle* getStyle() const;

    inline bool haveHfwCached(int width) const

    {

        return (hfw_width == width) || (width == sh_width && hfw_sh_height >= 0);

    }

    void recalcHFW(int w);

    void setupHfwLayoutData();

    uint fieldGrowthPolicy : 8;

    uint rowWrapPolicy : 8;

    uint has_hfw : 2;

    uint dirty : 2; // have we laid out yet?

    uint sizesDirty : 2; // have we (not) gathered layout item sizes?

    uint expandVertical : 1; // Do we expand vertically?

    uint expandHorizontal : 1; // Do we expand horizonally?

    Qt::Alignment labelAlignment;

    Qt::Alignment formAlignment;

    ItemMatrix m_matrix;

    QList<QFormLayoutItem *> m_things;

    int layoutWidth;    // the last width that we called setupVerticalLayoutData on (for vLayouts)

    int hfw_width;  // the last width we calculated HFW for

    int hfw_height; // what that height was

    int hfw_minheight;  // what that minheight was

    int hfw_sh_height;  // the hfw for sh_width

    int hfw_sh_minheight;   // the minhfw for sh_width

    int min_width;  // the width that gets turned into minSize (from updateSizes)

    int sh_width;   // the width that gets turned into prefSize (from updateSizes)

    int thresh_width; // the width that we start splitting label/field pairs at (from updateSizes)

    QSize minSize;

    QSize prefSize;

    int formMaxWidth;

    void calcSizeHints();

    QVector<QLayoutStruct> vLayouts; // set by setupVerticalLayoutData;

    int vLayoutCount;               // Number of rows we calculated in setupVerticalLayoutData

    int maxLabelWidth;              // the label width we calculated in setupVerticalLayoutData

    QVector<QLayoutStruct> hfwLayouts;

    int hSpacing;

    int vSpacing;

};

QFormLayoutPrivate::QFormLayoutPrivate()

    : fieldGrowthPolicy(DefaultFieldGrowthPolicy),

      rowWrapPolicy(DefaultRowWrapPolicy), has_hfw(false), dirty(true), sizesDirty(true),

      expandVertical(0), expandHorizontal(0), labelAlignment(0), formAlignment(0),

      layoutWidth(-1), hfw_width(-1), hfw_sh_height(-1), min_width(-1),

      sh_width(-1), thresh_width(QLAYOUTSIZE_MAX), hSpacing(-1), vSpacing(-1)

{

}

static Qt::Alignment fixedAlignment(Qt::Alignment alignment, Qt::LayoutDirection layoutDirection)

{

    if (layoutDirection == Qt::RightToLeft && alignment & Qt::AlignAbsolute) {

        // swap left and right, and eliminate absolute flag

        return Qt::Alignment((alignment & ~(Qt::AlignLeft | Qt::AlignRight | Qt::AlignAbsolute))

                             | ((alignment & Qt::AlignRight) ? Qt::AlignLeft : 0)

                             | ((alignment & Qt::AlignLeft) ? Qt::AlignRight : 0));

    } else {

        return alignment & ~Qt::AlignAbsolute;

    }

}

static int storageIndexFromLayoutItem(const QFormLayoutPrivate::ItemMatrix &m,

                                      QFormLayoutItem *item)

{

    if (item) {

        return m.storage().indexOf(item);

    } else {

        return -1;

    }

}

static void updateFormLayoutItem(QFormLayoutItem *item, int userVSpacing,

                                        QFormLayout::FieldGrowthPolicy fieldGrowthPolicy,

                                        bool fullRow)

{

    item->minSize = item->item->minimumSize();

    item->sizeHint = item->item->sizeHint();

    item->maxSize = item->item->maximumSize();

    if (!fullRow && (fieldGrowthPolicy == QFormLayout::FieldsStayAtSizeHint

                     || (fieldGrowthPolicy == QFormLayout::ExpandingFieldsGrow

                         && !(item->item->expandingDirections() & Qt::Horizontal))))

        item->maxSize.setWidth(item->sizeHint.width());

    item->isHfw = item->item->hasHeightForWidth();

    item->vSpace = userVSpacing;

}

/*

   Iterate over all the controls and gather their size information

   (min, sizeHint and max). Also work out what the spacing between

   pairs of controls should be, and figure out the min and sizeHint

   widths.

*/

void QFormLayoutPrivate::updateSizes()

{

    Q_Q(QFormLayout);

    if (sizesDirty) {

        QFormLayout::RowWrapPolicy wrapPolicy = q->rowWrapPolicy();

        bool wrapAllRows = (wrapPolicy == QFormLayout::WrapAllRows);

        bool dontWrapRows = (wrapPolicy == QFormLayout::DontWrapRows);

        int rr = m_matrix.rowCount();

        has_hfw = false;

        // If any control can expand, so can this layout

        // Wrapping doesn't affect expansion, though, just the minsize

        bool expandH = false;

        bool expandV = false;

        QFormLayoutItem *prevLbl = 0;

        QFormLayoutItem *prevFld = 0;

        QWidget *parent = q->parentWidget();

        QStyle *style = parent ? parent->style() : 0;

        int userVSpacing = q->verticalSpacing();

        int userHSpacing = wrapAllRows ? 0 : q->horizontalSpacing();

        int maxMinLblWidth = 0;

        int maxMinFldWidth = 0; // field with label

        int maxMinIfldWidth = 0; // independent field

        int maxShLblWidth = 0;

        int maxShFldWidth = 0;

        int maxShIfldWidth = 0;

        for (int i = 0; i < rr; ++i) {

            QFormLayoutItem *label = m_matrix(i, 0);

            QFormLayoutItem *field = m_matrix(i, 1);

            // Skip empty rows

            if (!label && !field)

                continue;

            if (label) {

                updateFormLayoutItem(label, userVSpacing, q->fieldGrowthPolicy(), false);

                if (label->isHfw)

                    has_hfw = true;

                Qt::Orientations o = label->expandingDirections();

                if (o & Qt::Vertical)

                    expandV = true;

                if (o & Qt::Horizontal)

                    expandH = true;

            }

            if (field) {

                updateFormLayoutItem(field, userVSpacing, q->fieldGrowthPolicy(), !label && field->fullRow);

                field->sbsHSpace = (!label && field->fullRow) ? 0 : userHSpacing;

                if (field->isHfw)

                    has_hfw = true;

                Qt::Orientations o = field->expandingDirections();

                if (o & Qt::Vertical)

                    expandV = true;

                if (o & Qt::Horizontal)

                    expandH = true;

            }

            // See if we need to calculate default spacings

            if ((userHSpacing < 0 || userVSpacing < 0) && style) {

                QSizePolicy::ControlTypes lbltypes =

                    QSizePolicy::ControlTypes(label ? label->controlTypes() : QSizePolicy::DefaultType);

                QSizePolicy::ControlTypes fldtypes =

                    QSizePolicy::ControlTypes(field ? field->controlTypes() : QSizePolicy::DefaultType);

                // VSpacing

                if (userVSpacing < 0) {

                    if (wrapAllRows) {

                        // label spacing is to a previous item

                        QFormLayoutItem *lbltop = prevFld ? prevFld : prevLbl;

                        // field spacing is to the label (or a previous item)

                        QFormLayoutItem *fldtop = label ? label : lbltop;

                        QSizePolicy::ControlTypes lbltoptypes =

                            QSizePolicy::ControlTypes(lbltop ? lbltop->controlTypes() : QSizePolicy::DefaultType);

                        QSizePolicy::ControlTypes fldtoptypes =

                            QSizePolicy::ControlTypes(fldtop ? fldtop->controlTypes() : QSizePolicy::DefaultType);

                        if (label && lbltop)

                            label->vSpace = style->combinedLayoutSpacing(lbltoptypes, lbltypes, Qt::Vertical, 0, parent);

                        if (field && fldtop)

                            field->vSpace = style->combinedLayoutSpacing(fldtoptypes, fldtypes, Qt::Vertical, 0, parent);

                    } else {

                        // Side by side..  we have to also consider the spacings to empty cells, which can strangely be more than

                        // non empty cells..

                        QFormLayoutItem *lbltop = prevLbl ? prevLbl : prevFld;

                        QFormLayoutItem *fldtop = prevFld;

                        QSizePolicy::ControlTypes lbltoptypes =

                            QSizePolicy::ControlTypes(lbltop ? lbltop->controlTypes() : QSizePolicy::DefaultType);

                        QSizePolicy::ControlTypes fldtoptypes =

                            QSizePolicy::ControlTypes(fldtop ? fldtop->controlTypes() : QSizePolicy::DefaultType);

                        // To be compatible to QGridLayout, we have to compare solitary labels & fields with both predecessors

                        if (label) {

                            if (!field) {

                                int lblspacing = style->combinedLayoutSpacing(lbltoptypes, lbltypes, Qt::Vertical, 0, parent);

                                int fldspacing = style->combinedLayoutSpacing(fldtoptypes, lbltypes, Qt::Vertical, 0, parent);

                                label->vSpace = qMax(lblspacing, fldspacing);

                            } else

                                label->vSpace = style->combinedLayoutSpacing(lbltoptypes, lbltypes, Qt::Vertical, 0, parent);

                        }

                        if (field) {

                            // check spacing against both the previous label and field

                            if (!label) {

                                int lblspacing = style->combinedLayoutSpacing(lbltoptypes, fldtypes, Qt::Vertical, 0, parent);

                                int fldspacing = style->combinedLayoutSpacing(fldtoptypes, fldtypes, Qt::Vertical, 0, parent);

                                field->vSpace = qMax(lblspacing, fldspacing);

                            } else

                                field->vSpace = style->combinedLayoutSpacing(fldtoptypes, fldtypes, Qt::Vertical, 0, parent);

                        }

                    }

                }

                // HSpacing

                // hard-coded the left and right control types so that all the rows have the same

                // inter-column spacing (otherwise the right column isn't always left aligned)

                if (userHSpacing < 0 && !wrapAllRows && (label || !field->fullRow) && field)

                    field->sbsHSpace = style->combinedLayoutSpacing(QSizePolicy::Label, QSizePolicy::LineEdit, Qt::Horizontal, 0, parent);

            }

            // Now update our min/sizehint widths

            // We choose to put the spacing in the field side in sbs, so

            // the right edge of the labels will align, but fields may

            // be a little ragged.. since different controls may have

            // different appearances, a slight raggedness in the left

            // edges of fields can be tolerated.

            // (Note - field->sbsHSpace is 0 for WrapAllRows mode)

            if (label) {

                maxMinLblWidth = qMax(maxMinLblWidth, label->minSize.width());

                maxShLblWidth = qMax(maxShLblWidth, label->sizeHint.width());

                if (field) {

                    maxMinFldWidth = qMax(maxMinFldWidth, field->minSize.width() + field->sbsHSpace);

                    maxShFldWidth = qMax(maxShFldWidth, field->sizeHint.width() + field->sbsHSpace);

                }

            } else if (field) {

                maxMinIfldWidth = qMax(maxMinIfldWidth, field->minSize.width());

                maxShIfldWidth = qMax(maxShIfldWidth, field->sizeHint.width());

            }

            prevLbl = label;

            prevFld = field;

        }

        // Now, finally update the min/sizeHint widths

        if (wrapAllRows) {

            sh_width = qMax(maxShLblWidth, qMax(maxShIfldWidth, maxShFldWidth));

            min_width = qMax(maxMinLblWidth, qMax(maxMinIfldWidth, maxMinFldWidth));

            // in two line, we don't care as much about the threshold width

            thresh_width = 0;

        } else if (dontWrapRows) {

            // This is just the max widths glommed together

            sh_width = qMax(maxShLblWidth + maxShFldWidth, maxShIfldWidth);

            min_width = qMax(maxMinLblWidth + maxMinFldWidth, maxMinIfldWidth);

            thresh_width = QWIDGETSIZE_MAX;

        } else {

            // This is just the max widths glommed together

            sh_width = qMax(maxShLblWidth + maxShFldWidth, maxShIfldWidth);

            // min width needs to be the min when everything is wrapped,

            // otherwise we'll never get set with a width that causes wrapping

            min_width = qMax(maxMinLblWidth, qMax(maxMinIfldWidth, maxMinFldWidth));

            // We split a pair at label sh + field min (### for now..)

            thresh_width = maxShLblWidth + maxMinFldWidth;

        }

        // Update the expansions

        expandVertical = expandV;

        expandHorizontal = expandH;

    }

    sizesDirty = false;

}

void QFormLayoutPrivate::recalcHFW(int w)

{

    setupHfwLayoutData();

    int h = 0;

    int mh = 0;

    for (int r = 0; r < vLayoutCount; ++r) {

        int spacing = hfwLayouts.at(r).spacing;

        h += hfwLayouts.at(r).sizeHint + spacing;

        mh += hfwLayouts.at(r).minimumSize + spacing;

    }

    if (sh_width > 0 && sh_width == w) {

        hfw_sh_height = qMin(QLAYOUTSIZE_MAX, h);

        hfw_sh_minheight = qMin(QLAYOUTSIZE_MAX, mh);

    } else {

        hfw_width = w;

        hfw_height = qMin(QLAYOUTSIZE_MAX, h);

        hfw_minheight = qMin(QLAYOUTSIZE_MAX, mh);

    }

}

void QFormLayoutPrivate::setupHfwLayoutData()

{

    // setupVerticalLayoutData must be called before this

    // setupHorizontalLayoutData must also be called before this

    // copies non hfw data into hfw

    // then updates size and min

    // Note: QGridLayout doesn't call minimumHeightForWidth,

    // but instead uses heightForWidth for both min and sizeHint.

    // For the common case where minimumHeightForWidth just calls

    // heightForWidth, we do the calculation twice, which can be

    // very expensive for word wrapped QLabels/QTextEdits, for example.

    // So we just use heightForWidth as well.

    int i;

    int rr = m_matrix.rowCount();

    hfwLayouts.clear();

    hfwLayouts.resize(vLayoutCount);

    for (i = 0; i < vLayoutCount; ++i)

        hfwLayouts[i] = vLayouts.at(i);