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

**

** 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 HbUtils 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 "hbdocumentloaderactions_p.h"

#include <QCoreApplication>

#include <QGraphicsLinearLayout> 

#include <QGraphicsGridLayout>

#include <QMetaObject>

#include <QMetaEnum>

#include <hbanchorlayout.h>

#include <hbstackedlayout.h>

#include <hbdocumentloader.h>

#include "hbdocumentloader_p.h"

#include <hbwidget_p.h>

#include <hbwidgetbase_p.h>

class AccessToMetadata : public QObject

    {

    public:

        int getEnumValue( const char *enumeration, const char *str )

            {

                QMetaObject metaobject = staticQtMetaObject; 

                QMetaEnum e = metaobject.enumerator( metaobject.indexOfEnumerator( enumeration ) );

                return e.keysToValue( str );

            }

    };        

/*

    \class HbDocumentLoaderActions

    \internal

    \proto

*/

HbDocumentLoaderActions::HbDocumentLoaderActions( HbDocumentLoaderPrivate *ref ) : 

    HbXmlLoaderAbstractActions(), 

    d( ref )

{

}

HbDocumentLoaderActions::~HbDocumentLoaderActions()

{

    reset();    

}

QObject* HbDocumentLoaderActions::createObject( const QString& type, const QString &name, const QString &plugin )

{

    return d->lookUp( type, name, plugin );

}

QObject* HbDocumentLoaderActions::createObjectWithFactory( const QString& type, const QString &name )

{

    return factory.create(type, name);

}

bool HbDocumentLoaderActions::pushObject( const QString& type, const QString &name )

{

    QObject *parent = findFromStack();

    if ( !parent && name.isEmpty() ) {

        HB_DOCUMENTLOADER_PRINT( QString( "Top level object must have name" ) );

        return false;

    }

    QObject *current = lookUp(type, name);

    if( current == 0 ) {

        HB_DOCUMENTLOADER_PRINT( QString( "Not supported object: " ) + type );

        return false;

    }

    Element e;

    e.type = OBJECT;

    e.data = current;

    mStack.append( e );

    if (parent) {

        current->setParent(parent);

    }

    HB_DOCUMENTLOADER_PRINT( QString( "ADD ELEMENT " ) + name );

    return true;

}

bool HbDocumentLoaderActions::pushWidget( const QString& type, const QString &name, const QString &role, const QString &plugin )

{

    bool parentWidget = false;

    QObject *parent = findFromStack(&parentWidget);

    if ( !parent && name.isEmpty() ) {

        HB_DOCUMENTLOADER_PRINT( QString( "Top level widget must have name" ) );

        return false;

    }

    if ( parent && !parentWidget ) {

        HB_DOCUMENTLOADER_PRINT( QString( "Object element cannot be parent of widget" ) );

        return false;

    }    

    QObject *current = lookUp(type, name, plugin);

    if( current == 0 ) {

        HB_DOCUMENTLOADER_PRINT( QString( "Not supported object: " ) + type );

        return false;

    }

    QGraphicsWidget *parentAsWidget = qobject_cast<QGraphicsWidget *>(parent);

    QGraphicsWidget *asWidget = qobject_cast<QGraphicsWidget *>(current);

    if (!asWidget || (parent && !parentAsWidget)) {

        HB_DOCUMENTLOADER_PRINT( QString( "Not a widget" ) );

        return false;

    } 

    if (parentAsWidget && !setWidgetRole(parentAsWidget, asWidget, role)) {

        HB_DOCUMENTLOADER_PRINT( QString( "Unable to set role" ) );

        return false;

    }

    Element e;

    e.type = WIDGET;

    e.data = current;

    mStack.append( e );

    HB_DOCUMENTLOADER_PRINT( QString( "ADD ELEMENT " ) + name );

    return true;

}

bool HbDocumentLoaderActions::pushSpacerItem( const QString &name, const QString &widget )

{

    if ( name.isEmpty() ) {

        HB_DOCUMENTLOADER_PRINT( QString( "SpacerItem needs to have a name" ) );

        return false;

    }

    // find the widget which owns the spacer i.e. the parent

    HbWidget *parent = 0;

    if( widget.isEmpty() ) {

        bool isWidget = false;

        parent = qobject_cast<HbWidget *>( findFromStack( &isWidget ) );

        if( !isWidget ) {

            HB_DOCUMENTLOADER_PRINT( QString( "SPACERITEM: CANNOT SET SPACERITEM TO NON-HBWIDGET " ) );

            return false;

        }

    } else if( !( mObjectMap.contains( widget ) ) ) {

        HB_DOCUMENTLOADER_PRINT( QString( "SPACERITEM: NO SUCH ITEM " ) + widget );

        return false;

    } else {   

        parent = qobject_cast<HbWidget *>( mObjectMap[ widget ].data() );

        if( !parent ) {

            HB_DOCUMENTLOADER_PRINT( QString( "SPACERITEM: CANNOT SET SPACERITEM TO NON-HBWIDGET " ) );

            return false;

        }

    }

    // look-up spacer item from widget

    QGraphicsLayoutItem *current = parent->layoutPrimitive( name );

    if ( !current ) {

        current =  static_cast<HbWidgetPrivate*>(HbWidgetBasePrivate::d_ptr(parent))->createSpacerItem(name);

    }

    // add it onto stack for further processing

    Element e;

    e.type = SPACERITEM;

    e.data = current;

    mStack.append( e );

    HB_DOCUMENTLOADER_PRINT( QString( "ADD ELEMENT " ) + name );

    return true;

}

bool HbDocumentLoaderActions::pushConnect( const QString &srcName, const QString &signalName, 

                                            const QString &dstName, const QString &slotName )

{

    if( srcName.isEmpty() || signalName.isEmpty() || dstName.isEmpty() || slotName.isEmpty() ) {

        HB_DOCUMENTLOADER_PRINT( QString( "Wrong parameters for signal/slot connection" ) );

        return false;

    }

    if( ! mObjectMap.contains( srcName ) ) {

        HB_DOCUMENTLOADER_PRINT( QString( "Unable to establish signal/slot connection, no instance with name " ) + srcName );

        return false;        

    }

    if( ! mObjectMap.contains( dstName ) ) {

        HB_DOCUMENTLOADER_PRINT( QString( "Unable to establish signal/slot connection, no instance with name " ) + dstName );

        return false;   

    }

    QObject *src = mObjectMap[ srcName ];

    if( !src ) {

        HB_DOCUMENTLOADER_PRINT( QString( "Unable to establish signal/slot connection, already destroyed " ) + srcName );

        return false;        

    }

    QObject *dst = mObjectMap[ dstName ];

    if( !dst ) {

        HB_DOCUMENTLOADER_PRINT( QString( "Unable to establish signal/slot connection, already destroyed " ) + dstName );

        return false;

    }

    const QMetaObject *msrc = src->metaObject();

    const QMetaObject *mdst = dst->metaObject();

    int signalIndex = msrc->indexOfSignal( QMetaObject::normalizedSignature( signalName.toLatin1() ) );

    int slotIndex = mdst->indexOfSlot( QMetaObject::normalizedSignature( slotName.toLatin1() ) );

    if( signalIndex == -1 ) {

        HB_DOCUMENTLOADER_PRINT( QString( "Unable to establish signal/slot connection, no such signal " ) + signalName );

        return false;

    }

    if( slotIndex == -1 ) {

        HB_DOCUMENTLOADER_PRINT( QString( "Unable to establish signal/slot connection, no such slot " ) + slotName );

        return false;

    }

    QMetaObject::connect(src, signalIndex, dst, slotIndex );    

    return true;

}

bool HbDocumentLoaderActions::pushProperty( const QString &propertyName, const QVariant &value )

{

    QObject *current = findFromStack();

    if( current == 0 ) {

        HB_DOCUMENTLOADER_PRINT( QString( "Unable to set property " ) + propertyName );

        return false;

    }

    if( propertyName.isEmpty() ) {

        HB_DOCUMENTLOADER_PRINT( QString( "No property name for " ) + propertyName );

        return false;

    } 

    QByteArray asLatin1 = propertyName.toLatin1();    

    current->setProperty( asLatin1, value );

    return true;    

}

bool HbDocumentLoaderActions::pushRef( const QString &name, const QString &role )

{

    QObject *current = findFromStack();

    QObject *ref = mObjectMap[ name ].data();

    if( ( current == 0 ) || ( ref == 0 ) ) {

        HB_DOCUMENTLOADER_PRINT( QString( "Wrong role name or role context" ) );

        return false;        

    }

    if ( !setObjectRole(current, ref, role)) {

        HB_DOCUMENTLOADER_PRINT( QString( "Unable to set role" ) );

        return false;

    }

    return true;

}

bool HbDocumentLoaderActions::setContentsMargins( qreal left, qreal top, qreal right, qreal bottom )

{

    bool isWidget = false;

    QGraphicsWidget *widget = qobject_cast<QGraphicsWidget *>(findFromStack(&isWidget));

    if( !isWidget || !widget ) {

        HB_DOCUMENTLOADER_PRINT( QString( "Cannot set contentsmargins for non-QGraphicsWidget" ) );

        return false;

    }

    widget->setContentsMargins( left, top, right, bottom );

    return true;

}

bool HbDocumentLoaderActions::setSizeHint(Qt::SizeHint hint, qreal *hintWidth, qreal *hintHeight, bool fixed)

{

    QGraphicsLayoutItem *current = findSpacerItemFromStackTop();

    if (!current) {

        bool isWidget = false;

        QGraphicsWidget *widget = qobject_cast<QGraphicsWidget *>(findFromStack(&isWidget));

        if( !isWidget || !widget ) {

            HB_DOCUMENTLOADER_PRINT( QString( "Cannot set sizehint for non-QGraphicsWidget" ) );

            return false;

        }

        current = widget;

    }

    switch (hint) {

    case Qt::MinimumSize: 

        if ( hintWidth ) {

            current->setMinimumWidth(*hintWidth);

        }

        if ( hintHeight ) {

            current->setMinimumHeight(*hintHeight);

        }

        break;

    case Qt::PreferredSize: 

        if ( hintWidth ) {

            current->setPreferredWidth(*hintWidth);

        }

        if ( hintHeight ) {

            current->setPreferredHeight(*hintHeight);

        }

        break;

    case Qt::MaximumSize: 

        if ( hintWidth ) {

            current->setMaximumWidth(*hintWidth);

        }

        if ( hintHeight ) {

            current->setMaximumHeight(*hintHeight);

        }

        break;

    default:

        break;

    }

    if (fixed) {

        QSizePolicy policy = current->sizePolicy();

        if ( hintWidth && *hintWidth >= 0) {

            policy.setHorizontalPolicy(QSizePolicy::Fixed);

        }

        if ( hintHeight && *hintHeight >= 0) {

            policy.setVerticalPolicy(QSizePolicy::Fixed);

        }

        current->setSizePolicy(policy);

    }

    return true;

}

bool HbDocumentLoaderActions::setZValue( qreal zValue )

{

    bool isWidget = false;

    QGraphicsWidget *widget = qobject_cast<QGraphicsWidget *>(findFromStack(&isWidget));

    if( !isWidget || !widget ) {

        HB_DOCUMENTLOADER_PRINT( QString( "Cannot set z value for non-QGraphicsWidget" ) );

        return false;

    }

    widget->setZValue( zValue );

    return true;

}

bool HbDocumentLoaderActions::setToolTip( const QString &tooltip )

{

    bool isWidget = false;

    QGraphicsWidget *widget = qobject_cast<QGraphicsWidget *>(findFromStack(&isWidget));

    if( !isWidget || !widget ) {

        HB_DOCUMENTLOADER_PRINT( QString( "Cannot set tooltip for non-QGraphicsWidget" ) );

        return false;

    }

    widget->setToolTip( tooltip );

    return true;

}

bool HbDocumentLoaderActions::setSizePolicy( 

    const QSizePolicy::Policy *horizontalPolicy, 

    const QSizePolicy::Policy *verticalPolicy, 

    const int *horizontalStretch,

    const int *verticalStretch )

{

    QGraphicsLayoutItem *current = findSpacerItemFromStackTop();

    if (!current) {

        bool isWidget = false;

        QGraphicsWidget *widget = qobject_cast<QGraphicsWidget *>(findFromStack(&isWidget));

        if( !isWidget || !widget ) {

            HB_DOCUMENTLOADER_PRINT( QString( "Cannot set size policy for non-QGraphicsWidget" ) );

            return false;

        }

        current = widget;

    }

    bool changed = false;

    QSizePolicy sizePolicy = current->sizePolicy();

    if ( horizontalPolicy && (*horizontalPolicy != sizePolicy.horizontalPolicy() ) ) {

        sizePolicy.setHorizontalPolicy( *horizontalPolicy );

        changed = true;

    }

    if ( verticalPolicy && (*verticalPolicy != sizePolicy.verticalPolicy() ) ) {

        sizePolicy.setVerticalPolicy( *verticalPolicy );

        changed = true;

    }

    if ( horizontalStretch && ( *horizontalStretch != sizePolicy.horizontalStretch() ) ) {

        sizePolicy.setHorizontalStretch( uchar( *horizontalStretch ) );

        changed = true;

    }

    if ( verticalStretch && ( *verticalStretch != sizePolicy.verticalStretch() ) ) {

        sizePolicy.setVerticalStretch( uchar( *verticalStretch ) );

        changed = true;

    }

    if ( changed ) {

        current->setSizePolicy( sizePolicy );

    }

    return true;

}

bool HbDocumentLoaderActions::createAnchorLayout( const QString &widget )

{

    QGraphicsWidget *parent = 0;

    if( widget.isEmpty() ) {

        bool isWidget = false;

        parent = qobject_cast<QGraphicsWidget *>( findFromStack( &isWidget ) );

        if( !isWidget ) {

            HB_DOCUMENTLOADER_PRINT( QString( "ANCHORLAYOUT: CANNOT SET LAYOUT TO NON-QGRAPHICSWIDGET " ) );

            return false;

        }

    } else if( !( mObjectMap.contains( widget ) ) ) {

        HB_DOCUMENTLOADER_PRINT( QString( "ANCHORLAYOUT: NO SUCH ITEM " ) + widget );

        return false;

    } else {   

        parent = qobject_cast<QGraphicsWidget *>( mObjectMap[ widget ].data() );

    }

    mCurrentLayout = new HbAnchorLayout();  

    parent->setLayout( mCurrentLayout );

    return true;

}

QGraphicsLayoutItem *findLayoutItem( const QGraphicsLayout &layout, const QString &layoutItemName ) 

{

    QGraphicsLayoutItem *result = 0;

    if ( layout.parentLayoutItem() ) {

        QGraphicsItem *asGraphicsItem = layout.parentLayoutItem()->graphicsItem();

        if ( asGraphicsItem && asGraphicsItem->isWidget() ){

            HbWidget *asWidget = qobject_cast<HbWidget*>( static_cast<QGraphicsWidget*>(asGraphicsItem) );

            if( asWidget ) {

                result = asWidget->layoutPrimitive( layoutItemName );

            }

        }

    }

    return result;

}

bool HbDocumentLoaderActions::addAnchorLayoutEdge( const QString &src, const QString &srcEdge, 

                                                    const QString &dst, const QString &dstEdge, qreal spacing, const QString &spacer )

{

    if ( !spacer.isEmpty() ) {

        // spacer is added

        // divide original anchor definition into two. src->dst becomes src->spacer->dst

        bool ok = true;

        if ( src.isEmpty() ) {

            // if the starting item is layout

            // "layout --(spacing)--> item" 

            // becomes 

            // "layout --(spacing)--> spacer --(0)--> item"

            ok &= addAnchorLayoutEdge( src, srcEdge, spacer, srcEdge, spacing );

            ok &= addAnchorLayoutEdge( spacer, getAnchorOppositeEdge(srcEdge), dst, dstEdge, 0 );

        } else {

            // if the starting item is not layout

            // "item1 --(spacing)--> item2" 

            // becomes 

            // "item1 --(spacing)--> spacer --(0)--> item2"

            ok &= addAnchorLayoutEdge( src, srcEdge, spacer, getAnchorOppositeEdge(srcEdge), spacing );

            ok &= addAnchorLayoutEdge( spacer, srcEdge, dst, dstEdge, 0 );

        }

        return ok;

    }

    QGraphicsLayoutItem *item1 = 0;

    QGraphicsLayoutItem *item2 = 0;

    HbAnchorLayout *layout = static_cast<HbAnchorLayout *>( mCurrentLayout );

    if( src.isEmpty() ) {

        item1 = layout;

    } else if( !( mObjectMap.contains( src ) ) ) {

        item1 = findLayoutItem( *layout, src );

        if ( !item1 ) {

            HB_DOCUMENTLOADER_PRINT( QString( "ANCHORLAYOUT: NO SUCH ITEM " ) + src );

            return false;

        }

    } else {

        item1 = qobject_cast<QGraphicsWidget *>( mObjectMap[ src ].data() );

    }

    if( dst.isEmpty() ) {

        item2 = layout;

    } else if( !( mObjectMap.contains( dst ) ) ) {

        item2 = findLayoutItem( *layout, dst );

        if ( !item2 ) {

            HB_DOCUMENTLOADER_PRINT( QString( "ANCHORLAYOUT: NO SUCH ITEM " ) + dst );

            return false;