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

**

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

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbCore module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** 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 developer.feedback@nokia.com.

**

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

#include "hbanchorlayout.h"

#include "hbanchor.h"

#include "hbanchor_p.h"

#include "hbanchorlayoutengine_p.h"

#include <QLayout>

#include <QDebug>

#include "hblayoututils_p.h"

//Uncomment next define in order to get more debug prints.

//Similar define exists also in the engine side.

//#define HBANCHORLAYOUT_DEBUG

/*!

    \class HbAnchorLayout

    \brief HbAnchorLayout manages geometries of its child items with anchors

    that connect the layout items with each other.

    It also allows layout items to be missing and can fix anchor attachments.

    Here is an example and some simple rules how anchor fixing works (the example is

    only for horizontal direction - the same needs to be done for portrait as well).

    If anchors set allow ambiguos positioning of items, then layout tries to set items

    size as close to preferred as possible.

    \image html hbanchorlayout1.png

    From the image above, we have decided that the green node is always present. This

    means that all the other nodes in the horizontal graph can be optional.

    \image html hbanchorlayout2.png

    Then, we create the anchors starting from the non-optional node and point towards

    the edges of the layout. The anchor layout definition in the WidgetML would look like:

    \code

    <anchoritem srcId="green_item" srcEdge="LEFT" dstId="blue_item" dstEdge="RIGHT" />

    <anchoritem srcId="blue_item" srcEdge="LEFT" dstId="" dstEdge="LEFT" />

    <anchoritem srcId="green_item" srcEdge="RIGHT" dstId="red_item" dstEdge="LEFT" />

    <anchoritem srcId="red_item" srcEdge="RIGHT" dstId="yellow_item" dstEdge="LEFT" />

    <anchoritem srcId="yellow_item" srcEdge="RIGHT" dstId="" dstEdge="RIGHT" />

    \endcode

    As mentioned, the green node needs be present always. In practice, this means that the

    parent widget, which owns this anchor layout, needs to have a child widget with item

    name "green_item". \c HbStyle::setItemName for more details.

    If an optional node is missing, the anchors pointing to the node are

    changed to point to the node after (=towards the parent layout) the missing one.

    \image html hbanchorlayout3.png

    In the picture above, the blue and yellow items are missing. The anchor is fixed by removing

    the anchor definitions starting from the missing nodes.

    \stable

*/

/*!

    \enum HbAnchorLayout::Edge

    This enum defines the edges of a layout item.

*/

/*

    \enum EdgeType

    \internal

*/

enum EdgeType {

    Horizontal = 0,

    Vertical

};

/*

    Type for mapping from layout item to node identifier.

    \internal

*/

typedef QMap<QGraphicsLayoutItem*, QString> ItemToNodeIdMap;

typedef ItemToNodeIdMap::iterator ItemToNodeIdMapIterator;

typedef ItemToNodeIdMap::const_iterator ItemToNodeIdMapConstIterator;

/*

    Result of findEndItem.

*/

struct HbFixedEndItemResult

{

    QGraphicsLayoutItem *mItem;

    HbAnchorLayout::Edge mEdge;

    qreal mMin;

    qreal mPref;

    qreal mMax;

    QSizePolicy::Policy mPolicy;

    HbAnchor::Direction mDirection;

};

class HbAnchorLayoutPrivate

{

public:

    Q_DECLARE_PUBLIC( HbAnchorLayout )

    HbAnchorLayoutPrivate();

    ~HbAnchorLayoutPrivate();

    void addItemIfNeeded(QGraphicsLayoutItem *item);

    static EdgeType edgeType( HbAnchorLayout::Edge edge );

    void setItemGeometries();

    void updateAnchorsAndItems();

    void createEquations( EdgeType type );

    int getEdgeIndex(QGraphicsLayoutItem *item, Hb::Edge edge);

    bool findEndItem(

        QList<HbFixedEndItemResult> &resultList,

        const HbAnchor *anchor,

        QStringList &ids) const;

    void resolveAnchors();

    void removeItemIfNeeded( QGraphicsLayoutItem *item );

    HbAnchor *setAnchor( HbAnchor *anchor );

    void setSizeProp( SizeProperty *v, QGraphicsLayoutItem *item, EdgeType type );

    void setSizeProp( SizeProperty *v, HbAnchor *item );

    GraphVertex *createCenterEdge( EdgeType type, QGraphicsLayoutItem *item,  Hb::Edge edge );

    void defineNextGeometry( const int itemIndexStart, const int itemIndexEnd, const int anchorIndex, const int definedItemIndex );

    QSizeF sizeHint(Qt::SizeHint which);

public:

    HbAnchorLayout * q_ptr;

    bool mEquationsDirty; // if true, we needed to re-create the equations (e.g. when new anchor is set)

    bool mValid;          // result of the calculations. false, if the equations cannot be solved.

    bool mInvalidateCalled; // set true in ::invalidate() and cleared after geometry is set in ::setGeometry

    bool mWrongAnchors;

    QList<HbAnchor*> mAllAnchors; // anchors that are set by user

    QList<HbAnchor*> mResolvedDynamicAnchors; //  references to generated anchors

    QList<HbAnchor*> mResolvedStaticAnchors; // references to anchors, that remains the same after resolving

    QList<HbAnchor*> mResolvedAnchors; // anchors that are passed to engine

    QList<QGraphicsLayoutItem*> mItems; // for addItem

    QList<QGraphicsLayoutItem*> mActualItems; // layouted items

    ItemToNodeIdMap mItemToNodeIdMap;

    QRectF mUsedRect;

    // new items

    QList<GraphEdge*> mEdgesVertical;

    QList<GraphEdge*> mEdgesHorizontal;

    QList<GraphVertex*> mVerticesVertical;

    QList<GraphVertex*> mVerticesHorizontal;

    QList<Expression*> mEquationsHorizontal;

    QList<Expression*> mEquationsVertical;

    VariableSet mVariablesHorizontal;

    VariableSet mVariablesVertical;

    Variable *mLayoutVarH;

    Variable *mLayoutVarV;

    QVector< bool > mAnchorsVisited;

    QVector< bool > mGeometryDefinedH;

    QVector< bool > mGeometryDefinedV;

    typedef struct {

        qreal x1, y1, x2, y2;

    } ItemGeometry;

    QVector< ItemGeometry > mItemsGeometry;

    Solution mSolutionHorizontal;

    Solution mSolutionVertical;

};

/*!

    \internal functions

*/

inline bool idConditionStartStart( HbAnchor *anchor1, HbAnchor *anchor2 )

{

    return ( !anchor1->startNodeId().isNull() ) && ( anchor1->startNodeId() == anchor2->startNodeId() );

}

inline bool idConditionEndEnd( HbAnchor *anchor1, HbAnchor *anchor2 )

{

    return ( !anchor1->endNodeId().isNull() ) && ( anchor1->endNodeId() == anchor2->endNodeId() );

}

inline bool idConditionStartEnd( HbAnchor *anchor1, HbAnchor *anchor2 )

{

    return ( !anchor1->startNodeId().isNull() ) && ( anchor1->startNodeId() == anchor2->endNodeId() );

}

inline bool idConditionEndStart( HbAnchor *anchor1, HbAnchor *anchor2 )

{

    return ( !anchor1->endNodeId().isNull() ) && ( anchor1->endNodeId() == anchor2->startNodeId() );

}

inline bool itemConditionStartStart( HbAnchor *anchor1, HbAnchor *anchor2 )

{

    return ( anchor1->startItem() != 0 ) && ( anchor1->startItem() == anchor2->startItem() );

}

inline bool itemConditionEndEnd( HbAnchor *anchor1, HbAnchor *anchor2 )

{

    return ( anchor1->endItem() != 0 ) && ( anchor1->endItem() == anchor2->endItem() );

}

inline bool itemConditionStartEnd( HbAnchor *anchor1, HbAnchor *anchor2 )

{

    return ( anchor1->startItem() != 0 ) && ( anchor1->startItem() == anchor2->endItem() );

}

inline bool itemConditionEndStart( HbAnchor *anchor1, HbAnchor *anchor2 )

{

    return ( anchor1->endItem() != 0 ) && ( anchor1->endItem() == anchor2->startItem() );

}

inline bool edgeConditionStartStart( HbAnchor *anchor1, HbAnchor *anchor2 )

{

    return anchor1->startEdge() == anchor2->startEdge();

}

inline bool edgeConditionEndEnd( HbAnchor *anchor1, HbAnchor *anchor2 )

{

    return anchor1->endEdge() == anchor2->endEdge();

}

inline bool edgeConditionStartEnd( HbAnchor *anchor1, HbAnchor *anchor2 )

{

    return anchor1->startEdge() == anchor2->endEdge();

}

inline bool edgeConditionEndStart( HbAnchor *anchor1, HbAnchor *anchor2 )

{

    return anchor1->endEdge() == anchor2->startEdge();

}

inline int directionMultiplier( HbAnchor *anchor )

{

    return ( ( anchor->direction() == HbAnchor::Positive )?(1):(-1) );

}

/*

    \class HbAnchorLayoutPrivate

    \internal

*/

HbAnchorLayoutPrivate::HbAnchorLayoutPrivate() : mEquationsDirty(false), mValid(true), mInvalidateCalled( false ), mWrongAnchors( false ),

                                                mUsedRect( 0, 0, 0, 0 ), mLayoutVarH( 0 ), mLayoutVarV( 0 )

{

}

/*

    \internal

*/

HbAnchorLayoutPrivate::~HbAnchorLayoutPrivate()

{

    qDeleteAll( mEdgesVertical );

    qDeleteAll( mEdgesHorizontal );

    qDeleteAll( mVerticesVertical );

    qDeleteAll( mVerticesHorizontal );

    qDeleteAll( mEquationsHorizontal );

    qDeleteAll( mEquationsVertical );

    qDeleteAll( mAllAnchors );

    qDeleteAll( mResolvedDynamicAnchors );

}

/*

    \internal

*/

EdgeType HbAnchorLayoutPrivate::edgeType( HbAnchorLayout::Edge edge )

{

    EdgeType type( Horizontal );

    if( edge == Hb::TopEdge || edge == Hb::BottomEdge || edge == Hb::CenterVEdge ) {

        type = Vertical;

    }

    return type;

}

#ifdef HBANCHORLAYOUT_DEBUG

/*

    Returns string representation of value in \c Edge enumeration.

    \internal

*/

static QString edgeAsText(HbAnchorLayout::Edge edge)

{

    QString result;

    switch (edge) {

    case Hb::LeftEdge:

        result = "LEFT";

        break;

    case Hb::RightEdge:

        result = "RIGHT";

        break;

    case Hb::CenterHEdge:

        result = "CENTERH";

        break;

    case Hb::TopEdge:

        result = "TOP";

        break;

    case Hb::BottomEdge:

        result = "BOTTOM";

        break;

    case Hb::CenterVEdge:

        result = "CENTERV";

        break;

    default:

        result = "<UNDEFINED>";

        break;

    }

    return result;

}

static QString itemAsText(QGraphicsLayoutItem* item, QGraphicsLayout *layout)

{

    QString result = "<emtpy>";

    if ( item ) {

        result = (item == layout) ? "HbAnchorLayout" : "<unknown>";

        QGraphicsItem *gItem = item->graphicsItem();

        if (gItem) {

            if (gItem->isWidget()) {

                result = static_cast<QGraphicsWidget*>(gItem)->metaObject()->className();

            }

        }

    }

    return result;

}

#endif // HBANCHORLAYOUT_DEBUG

/*

    \internal

*/

void HbAnchorLayoutPrivate::updateAnchorsAndItems()

{

    Q_Q(HbAnchorLayout);

    resolveAnchors();

#ifdef HBANCHORLAYOUT_DEBUG

    QGraphicsWidget* w = HbLayoutUtils::parentWidget( q );

    if ( w ) {

        qDebug() << "AnchorLayout: Updating anchors for" << w->metaObject()->className();

    }

    const QString parentId =

        mItemToNodeIdMap.contains(q) ? mItemToNodeIdMap.value(q) : QString();

    qDebug() << "-- -- resolved";

    qDebug() << "-- count: " << mResolvedAnchors.size() << ", parent: " << parentId;

    foreach (const HbAnchor *item, mResolvedAnchors) {

        const QString itemTemplate("-- (%1 [%2], %3) - (%4 [%5], %6) = %7");

        qDebug() <<

            itemTemplate

            .arg(item->startNodeId())

            .arg(itemAsText(item->startItem(), q))

            .arg(edgeAsText(item->startEdge()))

            .arg(item->endNodeId())

            .arg(itemAsText(item->endItem(), q))

            .arg(edgeAsText(item->endEdge()))

            .arg(item->preferredLength()).toAscii().data();

    }

    qDebug() << "-- -- all";

    qDebug() << "-- count: " << mAllAnchors.size() << ", parent: " << parentId;

    foreach (const HbAnchor *item, mAllAnchors) {

        const QString itemTemplate("-- (%1 [%2], %3) - (%4 [%5], %6) = %7");

        qDebug() <<

            itemTemplate

            .arg(item->startNodeId())

            .arg(itemAsText(item->startItem(), q))

            .arg(edgeAsText(item->startEdge()))

            .arg(item->endNodeId())

            .arg(itemAsText(item->endItem(), q))

            .arg(edgeAsText(item->endEdge()))

            .arg(item->preferredLength()).toAscii().data();

    }

    qDebug() << "-- ";

#endif // HBANCHORLAYOUT_DEBUG

    // HbAnchorLayout will only touch items that have anchors defined.

    mActualItems.clear();

    for (QList<HbAnchor*>::const_iterator it = mResolvedAnchors.constBegin();

         it != mResolvedAnchors.constEnd();

         ++it) {

        const HbAnchor* item = *it;

        if (item->startItem() != q && !mActualItems.contains(item->startItem())) {

            mActualItems.append(item->startItem());

        }

        if (item->endItem() != q && !mActualItems.contains(item->endItem())) {

            mActualItems.append(item->endItem());

        }

    }

}

void HbAnchorLayoutPrivate::setSizeProp( SizeProperty *v, HbAnchor *item )

{

    const QSizePolicy::Policy policy = item->sizePolicy();

    if ( policy & QSizePolicy::ShrinkFlag ) {

        v->min = item->minimumLength();

    } else {

        v->min = item->preferredLength();

    }

    if ( policy & (QSizePolicy::GrowFlag | QSizePolicy::ExpandFlag) ) {

        v->max = item->maximumLength();

    } else {

        v->max = item->preferredLength();

    }

    v->pref = qBound( v->min, item->preferredLength(), v->max );

    v->flags |= (v->min == v->max) ? SizeProperty::FlagFixed : 0;

    v->flags |= (policy & QSizePolicy::ExpandFlag) ? SizeProperty::FlagExpanding : 0;

    if( policy & QSizePolicy::IgnoreFlag ) {

        v->pref = v->min;

        v->flags |= SizeProperty::FlagExpanding;

    }

}

void HbAnchorLayoutPrivate::setSizeProp( SizeProperty *v, QGraphicsLayoutItem *item, EdgeType type )

{

    if( type == Vertical ) {

        const QSizePolicy::Policy verticalPolicy = item->sizePolicy().verticalPolicy();

        if ( verticalPolicy & QSizePolicy::ShrinkFlag ) {

            v->min = item->minimumHeight();

        } else {

            v->min = item->preferredHeight();

        }

        if ( verticalPolicy & (QSizePolicy::GrowFlag | QSizePolicy::ExpandFlag) ) {

            v->max = item->maximumHeight();

        } else {

            v->max = item->preferredHeight();

        }

        v->pref = qBound( v->min, item->preferredHeight(), v->max );

        v->flags |= (v->min == v->max) ? SizeProperty::FlagFixed : 0;

        v->flags |= (verticalPolicy & QSizePolicy::ExpandFlag) ? SizeProperty::FlagExpanding : 0;

        if( verticalPolicy & QSizePolicy::IgnoreFlag ) {

            v->pref = v->min;

            v->flags |= SizeProperty::FlagExpanding;

        }

    } else {

        const QSizePolicy::Policy horizontalPolicy = item->sizePolicy().horizontalPolicy();

        if ( horizontalPolicy & QSizePolicy::ShrinkFlag ) {

            v->min = item->minimumWidth();

        } else {

            v->min = item->preferredWidth();