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

**

** 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/qdeclarativeanchors_p_p.h"

#include "qdeclarativeitem.h"

#include "private/qdeclarativeitem_p.h"

#include <qdeclarativeinfo.h>

#include <QDebug>

QT_BEGIN_NAMESPACE

//TODO: should we cache relationships, so we don't have to check each time (parent-child or sibling)?

//TODO: support non-parent, non-sibling (need to find lowest common ancestor)

//### const item?

//local position

static qreal position(QGraphicsObject *item, QDeclarativeAnchorLine::AnchorLine anchorLine)

{

    qreal ret = 0.0;

    QGraphicsItemPrivate *d = QGraphicsItemPrivate::get(item);

    switch(anchorLine) {

    case QDeclarativeAnchorLine::Left:

        ret = item->x();

        break;

    case QDeclarativeAnchorLine::Right:

        ret = item->x() + d->width();

        break;

    case QDeclarativeAnchorLine::Top:

        ret = item->y();

        break;

    case QDeclarativeAnchorLine::Bottom:

        ret = item->y() + d->height();

        break;

    case QDeclarativeAnchorLine::HCenter:

        ret = item->x() + d->width()/2;

        break;

    case QDeclarativeAnchorLine::VCenter:

        ret = item->y() + d->height()/2;

        break;

    case QDeclarativeAnchorLine::Baseline:

        if (d->isDeclarativeItem)

            ret = item->y() + static_cast<QDeclarativeItem*>(item)->baselineOffset();

        break;

    default:

        break;

    }

    return ret;

}

//position when origin is 0,0

static qreal adjustedPosition(QGraphicsObject *item, QDeclarativeAnchorLine::AnchorLine anchorLine)

{

    int ret = 0;

    QGraphicsItemPrivate *d = QGraphicsItemPrivate::get(item);

    switch(anchorLine) {

    case QDeclarativeAnchorLine::Left:

        ret = 0;

        break;

    case QDeclarativeAnchorLine::Right:

        ret = d->width();

        break;

    case QDeclarativeAnchorLine::Top:

        ret = 0;

        break;

    case QDeclarativeAnchorLine::Bottom:

        ret = d->height();

        break;

    case QDeclarativeAnchorLine::HCenter:

        ret = d->width()/2;

        break;

    case QDeclarativeAnchorLine::VCenter:

        ret = d->height()/2;

        break;

    case QDeclarativeAnchorLine::Baseline:

        if (d->isDeclarativeItem)

            ret = static_cast<QDeclarativeItem*>(item)->baselineOffset();

        break;

    default:

        break;

    }

    return ret;

}

/*!

    \internal

    \class QDeclarativeAnchors

    \since 4.7

    \brief The QDeclarativeAnchors class provides a way to lay out items relative to other items.

    \warning Currently, only anchoring to siblings or parent is supported.

*/

QDeclarativeAnchors::QDeclarativeAnchors(QObject *parent)

  : QObject(*new QDeclarativeAnchorsPrivate(0), parent)

{

    qFatal("QDeclarativeAnchors::QDeclarativeAnchors(QObject*) called");

}

QDeclarativeAnchors::QDeclarativeAnchors(QGraphicsObject *item, QObject *parent)

  : QObject(*new QDeclarativeAnchorsPrivate(item), parent)

{

}

QDeclarativeAnchors::~QDeclarativeAnchors()

{

    Q_D(QDeclarativeAnchors);

    d->remDepend(d->fill);

    d->remDepend(d->centerIn);

    d->remDepend(d->left.item);

    d->remDepend(d->right.item);

    d->remDepend(d->top.item);

    d->remDepend(d->bottom.item);

    d->remDepend(d->vCenter.item);

    d->remDepend(d->hCenter.item);

    d->remDepend(d->baseline.item);

}

void QDeclarativeAnchorsPrivate::fillChanged()

{

    if (!fill || !isItemComplete())

        return;

    if (updatingFill < 2) {

        ++updatingFill;

        if (fill == item->parentItem()) {                         //child-parent

            setItemPos(QPointF(leftMargin, topMargin));

        } else if (fill->parentItem() == item->parentItem()) {   //siblings

            setItemPos(QPointF(fill->x()+leftMargin, fill->y()+topMargin));

        }

        QGraphicsItemPrivate *fillPrivate = QGraphicsItemPrivate::get(fill);

        setItemSize(QSizeF(fillPrivate->width()-leftMargin-rightMargin, fillPrivate->height()-topMargin-bottomMargin));

        --updatingFill;

    } else {

        // ### Make this certain :)

        qmlInfo(item) << QDeclarativeAnchors::tr("Possible anchor loop detected on fill.");

    }

}

void QDeclarativeAnchorsPrivate::centerInChanged()

{

    if (!centerIn || fill || !isItemComplete())

        return;

    if (updatingCenterIn < 2) {

        ++updatingCenterIn;

        QGraphicsItemPrivate *itemPrivate = QGraphicsItemPrivate::get(item);

        if (centerIn == item->parentItem()) {

            QGraphicsItemPrivate *parentPrivate = QGraphicsItemPrivate::get(item->parentItem());

            QPointF p((parentPrivate->width() - itemPrivate->width()) / 2. + hCenterOffset,

                      (parentPrivate->height() - itemPrivate->height()) / 2. + vCenterOffset);

            setItemPos(p);

        } else if (centerIn->parentItem() == item->parentItem()) {

            QGraphicsItemPrivate *centerPrivate = QGraphicsItemPrivate::get(centerIn);

            QPointF p(centerIn->x() + (centerPrivate->width() - itemPrivate->width()) / 2. + hCenterOffset,

                      centerIn->y() + (centerPrivate->height() - itemPrivate->height()) / 2. + vCenterOffset);

            setItemPos(p);

        }

        --updatingCenterIn;

    } else {

        // ### Make this certain :)

        qmlInfo(item) << QDeclarativeAnchors::tr("Possible anchor loop detected on centerIn.");

    }

}

void QDeclarativeAnchorsPrivate::clearItem(QGraphicsObject *item)

{

    if (!item)

        return;

    if (fill == item)

        fill = 0;

    if (centerIn == item)

        centerIn = 0;

    if (left.item == item) {

        left.item = 0;

        usedAnchors &= ~QDeclarativeAnchors::LeftAnchor;

    }

    if (right.item == item) {

        right.item = 0;

        usedAnchors &= ~QDeclarativeAnchors::RightAnchor;

    }

    if (top.item == item) {

        top.item = 0;

        usedAnchors &= ~QDeclarativeAnchors::TopAnchor;

    }

    if (bottom.item == item) {

        bottom.item = 0;

        usedAnchors &= ~QDeclarativeAnchors::BottomAnchor;

    }

    if (vCenter.item == item) {

        vCenter.item = 0;

        usedAnchors &= ~QDeclarativeAnchors::VCenterAnchor;

    }

    if (hCenter.item == item) {

        hCenter.item = 0;

        usedAnchors &= ~QDeclarativeAnchors::HCenterAnchor;

    }

    if (baseline.item == item) {

        baseline.item = 0;

        usedAnchors &= ~QDeclarativeAnchors::BaselineAnchor;

    }

}

void QDeclarativeAnchorsPrivate::addDepend(QGraphicsObject *item)

{

    if (!item)

        return;

    QGraphicsItemPrivate * itemPrivate = QGraphicsItemPrivate::get(item);

    if (itemPrivate->isDeclarativeItem) {

        QDeclarativeItemPrivate *p =

            static_cast<QDeclarativeItemPrivate *>(QGraphicsItemPrivate::get(item));

        p->addItemChangeListener(this, QDeclarativeItemPrivate::Geometry);

    } else if(itemPrivate->isWidget) {

        Q_Q(QDeclarativeAnchors);

        QGraphicsWidget *widget = static_cast<QGraphicsWidget *>(item);

        QObject::connect(widget, SIGNAL(destroyed(QObject *)), q, SLOT(_q_widgetDestroyed(QObject *)));

        QObject::connect(widget, SIGNAL(geometryChanged()), q, SLOT(_q_widgetGeometryChanged()));

    }

}

void QDeclarativeAnchorsPrivate::remDepend(QGraphicsObject *item)

{

    if (!item)

        return;

    QGraphicsItemPrivate * itemPrivate = QGraphicsItemPrivate::get(item);

    if (itemPrivate->isDeclarativeItem) {

        QDeclarativeItemPrivate *p =

            static_cast<QDeclarativeItemPrivate *>(itemPrivate);

        p->removeItemChangeListener(this, QDeclarativeItemPrivate::Geometry);

    } else if(itemPrivate->isWidget) {

        Q_Q(QDeclarativeAnchors);

        QGraphicsWidget *widget = static_cast<QGraphicsWidget *>(item);

        QObject::disconnect(widget, SIGNAL(destroyed(QObject *)), q, SLOT(_q_widgetDestroyed(QObject *)));

        QObject::disconnect(widget, SIGNAL(geometryChanged()), q, SLOT(_q_widgetGeometryChanged()));

    }

}

bool QDeclarativeAnchorsPrivate::isItemComplete() const

{

    return componentComplete;

}

void QDeclarativeAnchors::classBegin()

{

    Q_D(QDeclarativeAnchors);

    d->componentComplete = false;

}

void QDeclarativeAnchors::componentComplete()

{

    Q_D(QDeclarativeAnchors);

    d->componentComplete = true;

}

void QDeclarativeAnchorsPrivate::setItemHeight(qreal v)

{

    updatingMe = true;

    QGraphicsItemPrivate::get(item)->setHeight(v);

    updatingMe = false;

}

void QDeclarativeAnchorsPrivate::setItemWidth(qreal v)

{

    updatingMe = true;

    QGraphicsItemPrivate::get(item)->setWidth(v);

    updatingMe = false;

}

void QDeclarativeAnchorsPrivate::setItemX(qreal v)

{

    updatingMe = true;

    item->setX(v);

    updatingMe = false;

}

void QDeclarativeAnchorsPrivate::setItemY(qreal v)

{

    updatingMe = true;

    item->setY(v);

    updatingMe = false;

}

void QDeclarativeAnchorsPrivate::setItemPos(const QPointF &v)

{

    updatingMe = true;

    item->setPos(v);

    updatingMe = false;

}

void QDeclarativeAnchorsPrivate::setItemSize(const QSizeF &v)

{

    updatingMe = true;

    if(QGraphicsItemPrivate::get(item)->isWidget)

        static_cast<QGraphicsWidget *>(item)->resize(v);

    else if (QGraphicsItemPrivate::get(item)->isDeclarativeItem)

        static_cast<QDeclarativeItem *>(item)->setSize(v);

    updatingMe = false;

}

void QDeclarativeAnchorsPrivate::updateMe()

{

    if (updatingMe) {

        updatingMe = false;

        return;

    }

    fillChanged();

    centerInChanged();

    updateHorizontalAnchors();

    updateVerticalAnchors();

}

void QDeclarativeAnchorsPrivate::updateOnComplete()

{

    fillChanged();

    centerInChanged();

    updateHorizontalAnchors();

    updateVerticalAnchors();

}

void QDeclarativeAnchorsPrivate::_q_widgetDestroyed(QObject *obj)

{

    clearItem(qobject_cast<QGraphicsObject*>(obj));

}

void QDeclarativeAnchorsPrivate::_q_widgetGeometryChanged()

{

    fillChanged();

    centerInChanged();

    updateHorizontalAnchors();

    updateVerticalAnchors();

}

void QDeclarativeAnchorsPrivate::itemGeometryChanged(QDeclarativeItem *, const QRectF &newG, const QRectF &oldG)

{

    fillChanged();

    centerInChanged();

    if (newG.x() != oldG.x() || newG.width() != oldG.width())

        updateHorizontalAnchors();

    if (newG.y() != oldG.y() || newG.height() != oldG.height())

        updateVerticalAnchors();

}

QGraphicsObject *QDeclarativeAnchors::fill() const

{

    Q_D(const QDeclarativeAnchors);

    return d->fill;

}

void QDeclarativeAnchors::setFill(QGraphicsObject *f)

{

    Q_D(QDeclarativeAnchors);

    if (d->fill == f)

        return;

    if (!f) {

        d->remDepend(d->fill);

        d->fill = f;

        emit fillChanged();

        return;

    }

    if (f != d->item->parentItem() && f->parentItem() != d->item->parentItem()){

        qmlInfo(d->item) << tr("Cannot anchor to an item that isn't a parent or sibling.");

        return;

    }

    d->remDepend(d->fill);

    d->fill = f;

    d->addDepend(d->fill);

    emit fillChanged();

    d->fillChanged();

}

void QDeclarativeAnchors::resetFill()

{

    setFill(0);

}

QGraphicsObject *QDeclarativeAnchors::centerIn() const

{

    Q_D(const QDeclarativeAnchors);

    return d->centerIn;

}

void QDeclarativeAnchors::setCenterIn(QGraphicsObject* c)

{

    Q_D(QDeclarativeAnchors);

    if (d->centerIn == c)

        return;

    if (!c) {

        d->remDepend(d->centerIn);

        d->centerIn = c;

        emit centerInChanged();

        return;

    }

    if (c != d->item->parentItem() && c->parentItem() != d->item->parentItem()){

        qmlInfo(d->item) << tr("Cannot anchor to an item that isn't a parent or sibling.");

        return;

    }

    d->remDepend(d->centerIn);

    d->centerIn = c;

    d->addDepend(d->centerIn);

    emit centerInChanged();

    d->centerInChanged();

}

void QDeclarativeAnchors::resetCenterIn()

{

    setCenterIn(0);

}

bool QDeclarativeAnchorsPrivate::calcStretch(const QDeclarativeAnchorLine &edge1,

                                    const QDeclarativeAnchorLine &edge2,

                                    int offset1,

                                    int offset2,

                                    QDeclarativeAnchorLine::AnchorLine line,

                                    int &stretch)

{

    bool edge1IsParent = (edge1.item == item->parentItem());

    bool edge2IsParent = (edge2.item == item->parentItem());

    bool edge1IsSibling = (edge1.item->parentItem() == item->parentItem());

    bool edge2IsSibling = (edge2.item->parentItem() == item->parentItem());

    bool invalid = false;

    if ((edge2IsParent && edge1IsParent) || (edge2IsSibling && edge1IsSibling)) {

        stretch = ((int)position(edge2.item, edge2.anchorLine) + offset2)

                    - ((int)position(edge1.item, edge1.anchorLine) + offset1);

    } else if (edge2IsParent && edge1IsSibling) {

        stretch = ((int)position(edge2.item, edge2.anchorLine) + offset2)

                    - ((int)position(item->parentObject(), line)

                    + (int)position(edge1.item, edge1.anchorLine) + offset1);

    } else if (edge2IsSibling && edge1IsParent) {

        stretch = ((int)position(item->parentObject(), line) + (int)position(edge2.item, edge2.anchorLine) + offset2)

                    - ((int)position(edge1.item, edge1.anchorLine) + offset1);

    } else

        invalid = true;

    return invalid;

}

void QDeclarativeAnchorsPrivate::updateVerticalAnchors()

{

    if (fill || centerIn || !isItemComplete())

        return;

    if (updatingVerticalAnchor < 2) {

        ++updatingVerticalAnchor;

        QGraphicsItemPrivate *itemPrivate = QGraphicsItemPrivate::get(item);

        if (usedAnchors & QDeclarativeAnchors::TopAnchor) {

            //Handle stretching

            bool invalid = true;

            int height = 0;

            if (usedAnchors & QDeclarativeAnchors::BottomAnchor) {

                invalid = calcStretch(top, bottom, topMargin, -bottomMargin, QDeclarativeAnchorLine::Top, height);

            } else if (usedAnchors & QDeclarativeAnchors::VCenterAnchor) {

                invalid = calcStretch(top, vCenter, topMargin, vCenterOffset, QDeclarativeAnchorLine::Top, height);

                height *= 2;

            }

            if (!invalid)

                setItemHeight(height);

            //Handle top

            if (top.item == item->parentItem()) {

                setItemY(adjustedPosition(top.item, top.anchorLine) + topMargin);

            } else if (top.item->parentItem() == item->parentItem()) {

                setItemY(position(top.item, top.anchorLine) + topMargin);

            }

        } else if (usedAnchors & QDeclarativeAnchors::BottomAnchor) {

            //Handle stretching (top + bottom case is handled above)

            if (usedAnchors & QDeclarativeAnchors::VCenterAnchor) {

                int height = 0;

                bool invalid = calcStretch(vCenter, bottom, vCenterOffset, -bottomMargin,

                                              QDeclarativeAnchorLine::Top, height);

                if (!invalid)

                    setItemHeight(height*2);

            }

            //Handle bottom

            if (bottom.item == item->parentItem()) {

                setItemY(adjustedPosition(bottom.item, bottom.anchorLine) - itemPrivate->height() - bottomMargin);