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

**

** Copyright (C) 2010 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 "qglobal.h"

#ifndef QT_NO_GRAPHICSVIEW

#include "qgraphicslayout.h"

#include "qgraphicsscene.h"

#include "qgraphicslayoutitem.h"

#include "qgraphicslayoutitem_p.h"

#include "qwidget.h"

#include <QtDebug>

QT_BEGIN_NAMESPACE

/*

    COMBINE_SIZE() is identical to combineSize(), except that it

    doesn't evaluate 'size' unless necessary.

*/

#define COMBINE_SIZE(result, size) \

    do { \

        if ((result).width() < 0 || (result).height() < 0) \

            combineSize((result), (size)); \

    } while (false)

static void combineSize(QSizeF &result, const QSizeF &size)

{

    if (result.width() < 0)

        result.setWidth(size.width());

    if (result.height() < 0)

        result.setHeight(size.height());

}

static void boundSize(QSizeF &result, const QSizeF &size)

{

    if (size.width() >= 0 && size.width() < result.width())

        result.setWidth(size.width());

    if (size.height() >= 0 && size.height() < result.height())

        result.setHeight(size.height());

}

static void expandSize(QSizeF &result, const QSizeF &size)

{

    if (size.width() >= 0 && size.width() > result.width())

        result.setWidth(size.width());

    if (size.height() >= 0 && size.height() > result.height())

        result.setHeight(size.height());

}

static void normalizeHints(qreal &minimum, qreal &preferred, qreal &maximum, qreal &descent)

{

    if (minimum >= 0 && maximum >= 0 && minimum > maximum)

        minimum = maximum;

    if (preferred >= 0) {

        if (minimum >= 0 && preferred < minimum) {

            preferred = minimum;

        } else if (maximum >= 0 && preferred > maximum) {

            preferred = maximum;

        }

    }

    if (minimum >= 0 && descent > minimum)

        descent = minimum;

}

/*!

    \internal

*/

QGraphicsLayoutItemPrivate::QGraphicsLayoutItemPrivate(QGraphicsLayoutItem *par, bool layout)

    : parent(par), userSizeHints(0), isLayout(layout), ownedByLayout(false), graphicsItem(0)

{

}

/*!

    \internal

*/

QGraphicsLayoutItemPrivate::~QGraphicsLayoutItemPrivate()

{

    // Remove any lazily allocated data

    delete[] userSizeHints;

}

/*!

    \internal

*/

void QGraphicsLayoutItemPrivate::init()

{

    sizeHintCacheDirty = true;

    sizePolicy = QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);

}

/*!

    \internal

*/

QSizeF *QGraphicsLayoutItemPrivate::effectiveSizeHints(const QSizeF &constraint) const

{

    Q_Q(const QGraphicsLayoutItem);

    if (!sizeHintCacheDirty && cachedConstraint == constraint)

        return cachedSizeHints;

    for (int i = 0; i < Qt::NSizeHints; ++i) {

        cachedSizeHints[i] = constraint;

            combineSize(cachedSizeHints[i], userSizeHints[i]);

    }

    QSizeF &minS = cachedSizeHints[Qt::MinimumSize];

    QSizeF &prefS = cachedSizeHints[Qt::PreferredSize];

    QSizeF &maxS = cachedSizeHints[Qt::MaximumSize];

    QSizeF &descentS = cachedSizeHints[Qt::MinimumDescent];

    normalizeHints(minS.rwidth(), prefS.rwidth(), maxS.rwidth(), descentS.rwidth());

    normalizeHints(minS.rheight(), prefS.rheight(), maxS.rheight(), descentS.rheight());

    // if the minimum, preferred and maximum sizes contradict each other

    // (e.g. the minimum is larger than the maximum) we give priority to

    // the maximum size, then the minimum size and finally the preferred size

    COMBINE_SIZE(maxS, q->sizeHint(Qt::MaximumSize, maxS));

    combineSize(maxS, QSizeF(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX));

    expandSize(maxS, prefS);

    expandSize(maxS, minS);

    boundSize(maxS, QSizeF(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX));

    COMBINE_SIZE(minS, q->sizeHint(Qt::MinimumSize, minS));

    expandSize(minS, QSizeF(0, 0));

    boundSize(minS, prefS);

    boundSize(minS, maxS);

    COMBINE_SIZE(prefS, q->sizeHint(Qt::PreferredSize, prefS));

    expandSize(prefS, minS);

    boundSize(prefS, maxS);

    // Not supported yet

    // COMBINE_SIZE(descentS, q->sizeHint(Qt::MinimumDescent, constraint));

    cachedConstraint = constraint;

    sizeHintCacheDirty = false;

    return cachedSizeHints;

}

/*!

    \internal

    Returns the parent item of this layout, or 0 if this layout is

    not installed on any widget.

    If this is the item that the layout is installed on, it will return "itself".

    If the layout is a sub-layout, this function returns the parent

    widget of the parent layout.

    Note that it will traverse up the layout item hierarchy instead of just calling

    QGraphicsItem::parentItem(). This is on purpose.

    \sa parent()

*/

QGraphicsItem *QGraphicsLayoutItemPrivate::parentItem() const

{

    Q_Q(const QGraphicsLayoutItem);

    const QGraphicsLayoutItem *parent = q;

    while (parent && parent->isLayout()) {

        parent = parent->parentLayoutItem();

    }

    return parent ? parent->graphicsItem() : 0;

}

/*!

    \internal

     Ensures that userSizeHints is allocated.

     This function must be called before any dereferencing.

*/

void QGraphicsLayoutItemPrivate::ensureUserSizeHints()

{

    if (!userSizeHints)

        userSizeHints = new QSizeF[Qt::NSizeHints];

}

/*!

    \internal

    Sets the user size hint \a which to \a size. Use an invalid size to unset the size hint.

 */

void QGraphicsLayoutItemPrivate::setSize(Qt::SizeHint which, const QSizeF &size)

{

    Q_Q(QGraphicsLayoutItem);

    if (userSizeHints) {

        if (size == userSizeHints[which])

            return;

    } else if (!size.isValid()) {

        return;

    }

    ensureUserSizeHints();

    userSizeHints[which] = size;

    q->updateGeometry();

}

/*!

    \internal

    Sets the width of the user size hint \a which to \a width.

 */

void QGraphicsLayoutItemPrivate::setSizeComponent(

    Qt::SizeHint which, SizeComponent component, qreal value)

{

    Q_Q(QGraphicsLayoutItem);

    ensureUserSizeHints();

    qreal &userValue = (component == Width)

        ? userSizeHints[which].rwidth()

        : userSizeHints[which].rheight();

    if (value == userValue)

        return;

    userValue = value;

    q->updateGeometry();

}

/*!

    \class QGraphicsLayoutItem

    \brief The QGraphicsLayoutItem class can be inherited to allow your custom

    items to be managed by layouts.

    \since 4.4

    \ingroup graphicsview-api

    QGraphicsLayoutItem is an abstract class that defines a set of virtual

    functions describing sizes, size policies, and size hints for any object

    arranged by QGraphicsLayout. The API contains functions relevant

    for both the item itself and for the user of the item as most of

    QGraphicsLayoutItem's functions are also part of the subclass' public API.

    In most cases, existing layout-aware classes such as QGraphicsWidget and

    QGraphicsLayout already provide the functionality you require. However,

    subclassing these classes will enable you to create both graphical

    elements that work well with layouts (QGraphicsWidget) or custom layouts

    (QGraphicsLayout).

    \section1 Subclassing QGraphicsLayoutItem

    If you create a subclass of QGraphicsLayoutItem and reimplement its

    virtual functions, you will enable the layout to resize and position your

    item along with other QGraphicsLayoutItems including QGraphicsWidget

    and QGraphicsLayout.

    You can start by reimplementing important functions: the protected

    sizeHint() function, as well as the public setGeometry()

    function. If you want your items to be aware of immediate geometry

    changes, you can also reimplement updateGeometry().

    The geometry, size hint, and size policy affect the item's size and

    position. Calling setGeometry() will always resize and reposition the item

    immediately. Normally, this function is called by QGraphicsLayout after

    the layout has been activated, but it can also be called by the item's user

    at any time.

    The sizeHint() function returns the item' minimum, preferred and maximum

    size hints. You can override these properties by calling setMinimumSize(),

    setPreferredSize() or setMaximumSize(). You can also use functions such as

    setMinimumWidth() or setMaximumHeight() to set only the width or height

    component if desired.

    The effectiveSizeHint() function, on the other hand, returns a size hint

    for any given Qt::SizeHint, and guarantees that the returned size is bound

    to the minimum and maximum sizes and size hints. You can set the item's

    vertical and horizontal size policy by calling setSizePolicy(). The

    sizePolicy property is used by the layout system to describe how this item

    prefers to grow or shrink.

    \section1 Nesting QGraphicsLayoutItems

    QGraphicsLayoutItems can be nested within other QGraphicsLayoutItems,

    similar to layouts that can contain sublayouts. This is done either by

    passing a QGraphicsLayoutItem pointer to QGraphicsLayoutItem's

    protected constructor, or by calling setParentLayoutItem(). The

    parentLayoutItem() function returns a pointer to the item's layoutItem

    parent. If the item's parent is 0 or if the parent does not inherit

    from QGraphicsItem, the parentLayoutItem() function then returns 0.

    isLayout() returns true if the QGraphicsLayoutItem subclass is itself a

    layout, or false otherwise.

    Qt uses QGraphicsLayoutItem to provide layout functionality in the

    \l{Graphics View Framework}, but in the future its use may spread

    throughout Qt itself.

    \sa QGraphicsWidget, QGraphicsLayout, QGraphicsLinearLayout,

    QGraphicsGridLayout

*/

/*!

    Constructs the QGraphicsLayoutItem object. \a parent becomes the object's

    parent. If \a isLayout is true the item is a layout, otherwise

    \a isLayout is false.

*/

QGraphicsLayoutItem::QGraphicsLayoutItem(QGraphicsLayoutItem *parent, bool isLayout)

    : d_ptr(new QGraphicsLayoutItemPrivate(parent, isLayout))

{

    Q_D(QGraphicsLayoutItem);

    d->init();

    d->q_ptr = this;

}

/*!

    \internal

*/

QGraphicsLayoutItem::QGraphicsLayoutItem(QGraphicsLayoutItemPrivate &dd)

    : d_ptr(&dd)

{

    Q_D(QGraphicsLayoutItem);

    d->q_ptr = this;

}

/*!

    Destroys the QGraphicsLayoutItem object.

*/

QGraphicsLayoutItem::~QGraphicsLayoutItem()

{

    QGraphicsLayoutItem *parentLI = parentLayoutItem();

    if (parentLI && parentLI->isLayout()) {

        QGraphicsLayout *lay = static_cast<QGraphicsLayout*>(parentLI);

        // this is not optimal

        for (int i = lay->count() - 1; i >= 0; --i) {

            if (lay->itemAt(i) == this) {

                lay->removeAt(i);

                break;

            }

        }

    }

}

/*!

    \fn virtual QSizeF QGraphicsLayoutItem::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const = 0;

    This pure virtual function returns the size hint for \a which of the

    QGraphicsLayoutItem, using the width or height of \a constraint to

    constrain the output.

    Reimplement this function in a subclass of QGraphicsLayoutItem to

    provide the necessary size hints for your items.

    \sa effectiveSizeHint()

*/

/*!

    Sets the size policy to \a policy. The size policy describes how the item

    should grow horizontally and vertically when arranged in a layout.

    QGraphicsLayoutItem's default size policy is (QSizePolicy::Fixed,

    QSizePolicy::Fixed, QSizePolicy::DefaultType), but it is common for

    subclasses to change the default. For example, QGraphicsWidget defaults

    to (QSizePolicy::Preferred, QSizePolicy::Preferred,

    QSizePolicy::DefaultType).

    \sa sizePolicy(), QWidget::sizePolicy()

*/

void QGraphicsLayoutItem::setSizePolicy(const QSizePolicy &policy)

{

    Q_D(QGraphicsLayoutItem);

    if (d->sizePolicy == policy)

        return;

    d->sizePolicy = policy;

    updateGeometry();

}

/*!

    \overload

    This function is equivalent to calling

    setSizePolicy(QSizePolicy(\a hPolicy, \a vPolicy, \a controlType)).

    \sa sizePolicy(), QWidget::sizePolicy()

*/

void QGraphicsLayoutItem::setSizePolicy(QSizePolicy::Policy hPolicy,

                                        QSizePolicy::Policy vPolicy,

                                        QSizePolicy::ControlType controlType)

{

    setSizePolicy(QSizePolicy(hPolicy, vPolicy, controlType));

}

/*!

    Returns the current size policy.

    \sa setSizePolicy(), QWidget::sizePolicy()

*/

QSizePolicy QGraphicsLayoutItem::sizePolicy() const

{

    Q_D(const QGraphicsLayoutItem);

    return d->sizePolicy;

}

/*!

    Sets the minimum size to \a size. This property overrides sizeHint() for

    Qt::MinimumSize and ensures that effectiveSizeHint() will never return

    a size smaller than \a size. In order to unset the minimum size, use an

    invalid size.

    \sa minimumSize(), maximumSize(), preferredSize(), Qt::MinimumSize,

    sizeHint(), setMinimumWidth(), setMinimumHeight()

*/

void QGraphicsLayoutItem::setMinimumSize(const QSizeF &size)

{

    d_ptr->setSize(Qt::MinimumSize, size);

}

/*!

    \fn QGraphicsLayoutItem::setMinimumSize(qreal w, qreal h)

    This convenience function is equivalent to calling

    setMinimumSize(QSizeF(\a w, \a h)).

    \sa minimumSize(), setMaximumSize(), setPreferredSize(), sizeHint()

*/

/*!

    Returns the minimum size.

    \sa setMinimumSize(), preferredSize(), maximumSize(), Qt::MinimumSize,

    sizeHint()

*/

QSizeF QGraphicsLayoutItem::minimumSize() const

{

    return effectiveSizeHint(Qt::MinimumSize);

}

/*!

    Sets the minimum width to \a width.

    \sa minimumWidth(), setMinimumSize(), minimumSize()

*/

void QGraphicsLayoutItem::setMinimumWidth(qreal width)

{

    d_ptr->setSizeComponent(Qt::MinimumSize, d_ptr->Width, width);

}