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

**

** 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 QtDeclarative 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 "private/qdeclarativepositioners_p.h"

#include "private/qdeclarativepositioners_p_p.h"

#include <qdeclarative.h>

#include <qdeclarativestate_p.h>

#include <qdeclarativestategroup_p.h>

#include <qdeclarativestateoperations_p.h>

#include <qdeclarativeinfo.h>

#include <QtCore/qmath.h>

#include <QDebug>

#include <QCoreApplication>

QT_BEGIN_NAMESPACE

static const QDeclarativeItemPrivate::ChangeTypes watchedChanges

    = QDeclarativeItemPrivate::Geometry

    | QDeclarativeItemPrivate::SiblingOrder

    | QDeclarativeItemPrivate::Visibility

    | QDeclarativeItemPrivate::Opacity

    | QDeclarativeItemPrivate::Destroyed;

void QDeclarativeBasePositionerPrivate::watchChanges(QDeclarativeItem *other)

{

    QDeclarativeItemPrivate *otherPrivate = static_cast<QDeclarativeItemPrivate*>(QGraphicsItemPrivate::get(other));

    otherPrivate->addItemChangeListener(this, watchedChanges);

}

void QDeclarativeBasePositionerPrivate::unwatchChanges(QDeclarativeItem* other)

{

    QDeclarativeItemPrivate *otherPrivate = static_cast<QDeclarativeItemPrivate*>(QGraphicsItemPrivate::get(other));

    otherPrivate->removeItemChangeListener(this, watchedChanges);

}

/*!

    \internal

    \class QDeclarativeBasePositioner

    \brief The QDeclarativeBasePositioner class provides a base for QDeclarativeGraphics layouts.

    To create a QDeclarativeGraphics Positioner, simply subclass QDeclarativeBasePositioner and implement

    doLayout(), which is automatically called when the layout might need

    updating. In doLayout() use the setX and setY functions from QDeclarativeBasePositioner, and the

    base class will apply the positions along with the appropriate transitions. The items to

    position are provided in order as the protected member positionedItems.

    You also need to set a PositionerType, to declare whether you are positioning the x, y or both

    for the child items. Depending on the chosen type, only x or y changes will be applied.

    Note that the subclass is responsible for adding the

    spacing in between items.

*/

QDeclarativeBasePositioner::QDeclarativeBasePositioner(PositionerType at, QDeclarativeItem *parent)

    : QDeclarativeItem(*(new QDeclarativeBasePositionerPrivate), parent)

{

    Q_D(QDeclarativeBasePositioner);

    d->init(at);

}

QDeclarativeBasePositioner::QDeclarativeBasePositioner(QDeclarativeBasePositionerPrivate &dd, PositionerType at, QDeclarativeItem *parent)

    : QDeclarativeItem(dd, parent)

{

    Q_D(QDeclarativeBasePositioner);

    d->init(at);

}

QDeclarativeBasePositioner::~QDeclarativeBasePositioner()

{

    Q_D(QDeclarativeBasePositioner);

    for (int i = 0; i < positionedItems.count(); ++i)

        d->unwatchChanges(positionedItems.at(i).item);

    positionedItems.clear();

}

int QDeclarativeBasePositioner::spacing() const

{

    Q_D(const QDeclarativeBasePositioner);

    return d->spacing;

}

void QDeclarativeBasePositioner::setSpacing(int s)

{

    Q_D(QDeclarativeBasePositioner);

    if (s==d->spacing)

        return;

    d->spacing = s;

    prePositioning();

    emit spacingChanged();

}

QDeclarativeTransition *QDeclarativeBasePositioner::move() const

{

    Q_D(const QDeclarativeBasePositioner);

    return d->moveTransition;

}

void QDeclarativeBasePositioner::setMove(QDeclarativeTransition *mt)

{

    Q_D(QDeclarativeBasePositioner);

    if (mt == d->moveTransition)

        return;

    d->moveTransition = mt;

    emit moveChanged();

}

QDeclarativeTransition *QDeclarativeBasePositioner::add() const

{

    Q_D(const QDeclarativeBasePositioner);

    return d->addTransition;

}

void QDeclarativeBasePositioner::setAdd(QDeclarativeTransition *add)

{

    Q_D(QDeclarativeBasePositioner);

    if (add == d->addTransition)

        return;

    d->addTransition = add;

    emit addChanged();

}

void QDeclarativeBasePositioner::componentComplete()

{

    Q_D(QDeclarativeBasePositioner);

    QDeclarativeItem::componentComplete();

    positionedItems.reserve(d->QGraphicsItemPrivate::children.count());

    prePositioning();

    reportConflictingAnchors();

}

QVariant QDeclarativeBasePositioner::itemChange(GraphicsItemChange change,

                                       const QVariant &value)

{

    Q_D(QDeclarativeBasePositioner);

    if (change == ItemChildAddedChange){

        QGraphicsItem* item = value.value<QGraphicsItem*>();

        QDeclarativeItem* child = 0;

        if(item)

            child = qobject_cast<QDeclarativeItem*>(item->toGraphicsObject());

        if (child)

            prePositioning();

    } else if (change == ItemChildRemovedChange) {

        QGraphicsItem* item = value.value<QGraphicsItem*>();

        QDeclarativeItem* child = 0;

        if(item)

            child = qobject_cast<QDeclarativeItem*>(item->toGraphicsObject());

        if (child) {

            QDeclarativeBasePositioner::PositionedItem posItem(child);

            int idx = positionedItems.find(posItem);

            if (idx >= 0) {

                d->unwatchChanges(child);

                positionedItems.remove(idx);

            }

            prePositioning();

        }

    }

    return QDeclarativeItem::itemChange(change, value);

}

void QDeclarativeBasePositioner::prePositioning()

{

    Q_D(QDeclarativeBasePositioner);

    if (!isComponentComplete())

        return;

    if (d->doingPositioning)

        return;

    d->queuedPositioning = false;

    d->doingPositioning = true;

    //Need to order children by creation order modified by stacking order

    QList<QGraphicsItem *> children = d->QGraphicsItemPrivate::children;

    qSort(children.begin(), children.end(), d->insertionOrder);

    QPODVector<PositionedItem,8> oldItems;

    positionedItems.copyAndClear(oldItems);

    for (int ii = 0; ii < children.count(); ++ii) {

        QDeclarativeItem *child = qobject_cast<QDeclarativeItem *>(children.at(ii));

        if (!child)

            continue;

        QDeclarativeItemPrivate *childPrivate = static_cast<QDeclarativeItemPrivate*>(QGraphicsItemPrivate::get(child));

        PositionedItem *item = 0;

        PositionedItem posItem(child);

        int wIdx = oldItems.find(posItem);

        if (wIdx < 0) {

            d->watchChanges(child);

            positionedItems.append(posItem);

            item = &positionedItems[positionedItems.count()-1];

            item->isNew = true;

            if (child->opacity() <= 0.0 || childPrivate->explicitlyHidden)

                item->isVisible = false;

        } else {

            item = &oldItems[wIdx];

            // Items are only omitted from positioning if they are explicitly hidden

            // i.e. their positioning is not affected if an ancestor is hidden.

            if (child->opacity() <= 0.0 || childPrivate->explicitlyHidden) {

                item->isVisible = false;

            } else if (!item->isVisible) {

                item->isVisible = true;

                item->isNew = true;

            } else {

                item->isNew = false;

            }

            positionedItems.append(*item);

        }

    }

    QSizeF contentSize;

    doPositioning(&contentSize);

    if(d->addTransition || d->moveTransition)

        finishApplyTransitions();

    d->doingPositioning = false;

    //Set implicit size to the size of its children

    setImplicitHeight(contentSize.height());

    setImplicitWidth(contentSize.width());

}

void QDeclarativeBasePositioner::positionX(int x, const PositionedItem &target)

{

    Q_D(QDeclarativeBasePositioner);

    if(d->type == Horizontal || d->type == Both){

        if (target.isNew) {

            if (!d->addTransition)

                target.item->setX(x);

            else

                d->addActions << QDeclarativeAction(target.item, QLatin1String("x"), QVariant(x));

        } else if (x != target.item->x()) {

            if (!d->moveTransition)

                target.item->setX(x);

            else

                d->moveActions << QDeclarativeAction(target.item, QLatin1String("x"), QVariant(x));

        }

    }

}

void QDeclarativeBasePositioner::positionY(int y, const PositionedItem &target)

{

    Q_D(QDeclarativeBasePositioner);

    if(d->type == Vertical || d->type == Both){

        if (target.isNew) {

            if (!d->addTransition)

                target.item->setY(y);

            else

                d->addActions << QDeclarativeAction(target.item, QLatin1String("y"), QVariant(y));

        } else if (y != target.item->y()) {

            if (!d->moveTransition)

                target.item->setY(y);

            else

                d->moveActions << QDeclarativeAction(target.item, QLatin1String("y"), QVariant(y));

        }

    }

}

void QDeclarativeBasePositioner::finishApplyTransitions()

{

    Q_D(QDeclarativeBasePositioner);

    // Note that if a transition is not set the transition manager will

    // apply the changes directly, in the case add/move aren't set

    d->addTransitionManager.transition(d->addActions, d->addTransition);

    d->moveTransitionManager.transition(d->moveActions, d->moveTransition);

    d->addActions.clear();

    d->moveActions.clear();

}

static inline bool isInvisible(QDeclarativeItem *child)

{

    QDeclarativeItemPrivate *childPrivate = static_cast<QDeclarativeItemPrivate*>(QGraphicsItemPrivate::get(child));

    return child->opacity() == 0.0 || childPrivate->explicitlyHidden || !child->width() || !child->height();

}

/*!

  \qmlclass Column QDeclarativeColumn

    \since 4.7

  \brief The Column item arranges its children vertically.

  \inherits Item

  The Column item positions its child items so that they are vertically

    aligned and not overlapping. Spacing between items can be added.

  The below example positions differently shaped rectangles using a Column.

  \table

  \row

  \o \image verticalpositioner_example.png

  \o

  \qml

Column {

    spacing: 2

    Rectangle { color: "red"; width: 50; height: 50 }

    Rectangle { color: "green"; width: 20; height: 50 }

    Rectangle { color: "blue"; width: 50; height: 20 }

}

  \endqml

  \endtable

  Column also provides for transitions to be set when items are added, moved,

  or removed in the positioner. Adding and removing apply both to items which are deleted

  or have their position in the document changed so as to no longer be children of the positioner,

  as well as to items which have their opacity set to or from zero so as to appear or disappear.

  \table

  \row

  \o \image verticalpositioner_transition.gif

  \o

  \qml

Column {

    spacing: 2

    add: ...

    move: ...

    ...

}

  \endqml

  \endtable

  Note that the positioner assumes that the x and y positions of its children

  will not change. If you manually change the x or y properties in script, bind

  the x or y properties, use anchors on a child of a positioner, or have the

  height of a child depend on the position of a child, then the

  positioner may exhibit strange behaviour. If you need to perform any of these

  actions, consider positioning the items without the use of a Column.

  Items with a width or height of 0 will not be positioned.

  \sa Row, {declarative/positioners}{Positioners example}

*/

/*!

    \qmlproperty Transition Column::add

    This property holds the transition to be applied when adding an

    item to the positioner. The transition will only be applied to the

    added item(s).  Positioner transitions will only affect the

    position (x,y) of items.

    Added can mean that either the object has been created or

    reparented, and thus is now a child or the positioner, or that the

    object has had its opacity increased from zero, and thus is now

    visible.

*/

/*!

    \qmlproperty Transition Column::move

    This property holds the transition to apply when moving an item

    within the positioner.  Positioner transitions will only affect

    the position (x,y) of items.

    This can happen when other items are added or removed from the

    positioner, or when items resize themselves.

    \table

    \row

    \o \image positioner-move.gif

    \o

    \qml

Column {

    move: Transition {

        NumberAnimation {

            properties: "y"

            easing.type: Easing.OutBounce

        }

    }

}

    \endqml

    \endtable

*/

/*!

  \qmlproperty int Column::spacing

  spacing is the amount in pixels left empty between each adjacent

  item, and defaults to 0.

  The below example places a \l Grid containing a red, a blue and a

  green rectangle on a gray background. The area the grid positioner

  occupies is colored white. The top positioner has the default of no spacing,

  and the bottom positioner has its spacing set to 2.

  \image spacing_a.png

  \image spacing_b.png

*/

/*!

    \internal

    \class QDeclarativeColumn

    \brief The QDeclarativeColumn class lines up items vertically.

*/

QDeclarativeColumn::QDeclarativeColumn(QDeclarativeItem *parent)

: QDeclarativeBasePositioner(Vertical, parent)

{

}

void QDeclarativeColumn::doPositioning(QSizeF *contentSize)

{

    int voffset = 0;

    for (int ii = 0; ii < positionedItems.count(); ++ii) {

        const PositionedItem &child = positionedItems.at(ii);

        if (!child.item || isInvisible(child.item))

            continue;

        if(child.item->y() != voffset)

            positionY(voffset, child);

        contentSize->setWidth(qMax(contentSize->width(), child.item->width()));

        voffset += child.item->height();

        voffset += spacing();

    }

    contentSize->setHeight(voffset - spacing());

}

void QDeclarativeColumn::reportConflictingAnchors()

{

    QDeclarativeBasePositionerPrivate *d = static_cast<QDeclarativeBasePositionerPrivate*>(QDeclarativeBasePositionerPrivate::get(this));

    for (int ii = 0; ii < positionedItems.count(); ++ii) {

        const PositionedItem &child = positionedItems.at(ii);

        if (child.item) {

            QDeclarativeAnchors *anchors = QDeclarativeItemPrivate::get(child.item)->_anchors;

            if (anchors) {

                QDeclarativeAnchors::Anchors usedAnchors = anchors->usedAnchors();

                if (usedAnchors & QDeclarativeAnchors::TopAnchor ||

                    usedAnchors & QDeclarativeAnchors::BottomAnchor ||

                    usedAnchors & QDeclarativeAnchors::VCenterAnchor ||

                    anchors->fill() || anchors->centerIn()) {

                    d->anchorConflict = true;

                    break;

                }

            }

        }

    }

    if (d->anchorConflict) {

        qmlInfo(this) << "Cannot specify top, bottom, verticalCenter, fill or centerIn anchors for items inside Column";

    }

}

/*!

  \qmlclass Row QDeclarativeRow

  \since 4.7

  \brief The Row item arranges its children horizontally.

  \inherits Item

  The Row item positions its child items so that they are

  horizontally aligned and not overlapping. 

  Use \l spacing to set the spacing between items in a Row, and use the

  \l add and \l move properties to set the transitions that should be applied

  when items are added to, removed from, or re-positioned within the Row.

  The below example lays out differently shaped rectangles using a Row.

  \qml

Row {

    spacing: 2

    Rectangle { color: "red"; width: 50; height: 50 }

    Rectangle { color: "green"; width: 20; height: 50 }

    Rectangle { color: "blue"; width: 50; height: 20 }

}

  \endqml

  \image horizontalpositioner_example.png

  Note that the positioner assumes that the x and y positions of its children

  will not change. If you manually change the x or y properties in script, bind

  the x or y properties, use anchors on a child of a positioner, or have the

  width of a child depend on the position of a child, then the

  positioner may exhibit strange behaviour. If you need to perform any of these

  actions, consider positioning the items without the use of a Row.

  Items with a width or height of 0 will not be positioned.

  \sa Column, {declarative/positioners}{Positioners example}

*/

/*!

    \qmlproperty Transition Row::add

    This property holds the transition to apply when adding an item to the positioner.

    The transition will only be applied to the added item(s).

    Positioner transitions will only affect the position (x,y) of items.

    An object is considered to be added to the positioner if it has been

    created or reparented and thus is now a child or the positioner, or if the

    object has had its opacity increased from zero, and thus is now

    visible.

*/

/*!

    \qmlproperty Transition Row::move