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

**

** 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 <hbxmlloaderabstractsyntax_p.h>

#include <QCoreApplication>

#include <QGraphicsLinearLayout>

#include <QGraphicsGridLayout>

#include <QMetaObject>

#include <QMetaEnum>

#include <QDebug>

#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, const HbMainWindow *window ) :

    HbXmlLoaderBaseActions(),

    d( ref )

{

    if ( window ) {

        mCurrentProfile = HbDeviceProfile::profile(window);

    } else {

        mCurrentProfile = HbDeviceProfile::current();

    }

}

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 mFactory.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;

    }

    if( current == 0 ) {

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

        return false;

    }

    HbXml::Element e;

    e.type = HbXml::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 parentIsWidget = false;

    QObject *parent = findFromStack(&parentIsWidget);

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

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

        return false;

    }

    if ( parent && !parentIsWidget ) {

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

        return false;

    }

    ObjectMapItem item = lookUp(type, name, plugin);

    if( current == 0 ) {

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

        return false;

    }

    QGraphicsWidget *parentAsWidget(0);

    if (parentIsWidget) {

        parentAsWidget = static_cast<QGraphicsWidget *>(parent);

    }

    QGraphicsWidget *asWidget(0);

        asWidget = static_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;

    }

    HbXml::Element e;

    e.type = HbXml::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 {

        ObjectMapItem &item = mObjectMap[ widget ];

        }

        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

    HbXml::Element e;

    e.type = HbXml::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;

    }

    if( !src ) {

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

        return false;

    }

    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 char *propertyName, const HbXmlVariable &variable )

{

    QObject *current = findFromStack();

    if( current == 0 ) {

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

        return false;

    }

    QVariant value;

    bool ok = variableToQVariant(variable, value);

    if (ok) {

        bool isQProperty = current->setProperty( propertyName, value );

        if ( !isQProperty ) {

            qWarning() << "DOCML warning: Dynamic property" << propertyName << "set. Property may have been removed from" << current->metaObject()->className();

        }

    }

    return ok;

}

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

{

    QObject *current = findFromStack();

    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::pushContainer( const char *propertyName,

                                             HbXmlLoaderAbstractSyntax::DocumentLexems type,

                                             const QList<HbXmlVariable*> &container )

{

    bool result = true;

    if ( type == HbXmlLoaderAbstractSyntax::CONTAINER_STRINGLIST ) {

        QStringList list;

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

            QVariant variant;

            result = variableToQVariant(*(container.value(i)), variant);

            if ( result ) {

                list.append( variant.toString() );

            }

        }

        if ( result ) {

            QObject *current = findFromStack();

            if (current == 0) {

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

                result = false;

            }

            if (result) {

                current->setProperty( propertyName, list );

            }

        }

    } else {

        result = false;

    }

    return result;

}

bool HbDocumentLoaderActions::setContentsMargins( const HbXmlLengthValue &left,

                                                 const HbXmlLengthValue &top,

                                                 const HbXmlLengthValue &right,

                                                 const HbXmlLengthValue &bottom )

{

    bool isWidget = false;

    QObject* obj = findFromStack(&isWidget);

    if( !obj || !isWidget ) {

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

        return false;

    }

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

    qreal leftVal=0, topVal=0, rightVal=0, bottomVal=0;

    bool ok = true;

    if (left.mType != HbXmlLengthValue::None) {

        ok &= toPixels(left, leftVal);

    }

    if (top.mType != HbXmlLengthValue::None) {

        ok &= toPixels(top, topVal);

    }

    if (right.mType != HbXmlLengthValue::None) {

        ok &= toPixels(right, rightVal);

    }

    if (bottom.mType != HbXmlLengthValue::None) {

        ok &= toPixels(bottom, bottomVal);

    }

    if ( ok ) {

        widget->setContentsMargins( leftVal, topVal, rightVal, bottomVal );

    }

    return ok;

}

bool HbDocumentLoaderActions::setSizeHint(Qt::SizeHint hint, const HbXmlLengthValue &hintWidth, const HbXmlLengthValue &hintHeight, bool fixed)

{

    QGraphicsLayoutItem *current = findSpacerItemFromStackTop();

    if (!current) {

        bool isWidget = false;

        QObject* obj = findFromStack(&isWidget);

        if( !obj || !isWidget ) {

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

            return false;

        }

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

        current = widget;

    }

    qreal hintWidthVal, hintHeightVal;

    bool ok = true;

    if ( hintWidth.mType != HbXmlLengthValue::None ) {

        ok &= toPixels(hintWidth, hintWidthVal);

    }

    if ( hintHeight.mType != HbXmlLengthValue::None ) {

        ok &= toPixels(hintHeight, hintHeightVal);

    }

    if (!ok) {

        return false;

    }

    // TODO: Use set <Min/Pref/Max> Size if both declared. It's more efficient.

    switch (hint) {

    case Qt::MinimumSize:

        if ( hintWidth.mType != HbXmlLengthValue::None ) {

            current->setMinimumWidth(hintWidthVal);

        }

        if ( hintHeight.mType != HbXmlLengthValue::None ) {

            current->setMinimumHeight(hintHeightVal);

        }

        break;

    case Qt::PreferredSize:

        if ( hintWidth.mType != HbXmlLengthValue::None ) {

            current->setPreferredWidth(hintWidthVal);

        }

        if ( hintHeight.mType != HbXmlLengthValue::None ) {

            current->setPreferredHeight(hintHeightVal);

        }

        break;

    case Qt::MaximumSize:

        if ( hintWidth.mType != HbXmlLengthValue::None ) {

            current->setMaximumWidth(hintWidthVal);

        }

        if ( hintHeight.mType != HbXmlLengthValue::None ) {

            current->setMaximumHeight(hintHeightVal);

        }

        break;

    default:

        break;

    }

    if (fixed) {

        QSizePolicy policy = current->sizePolicy();

        if ( hintWidth.mType != HbXmlLengthValue::None && hintWidthVal >= 0) {

            policy.setHorizontalPolicy(QSizePolicy::Fixed);

        }

        if ( hintHeight.mType != HbXmlLengthValue::None && hintHeightVal >= 0) {

            policy.setVerticalPolicy(QSizePolicy::Fixed);

        }

        current->setSizePolicy(policy);

    }

    return true;

}

bool HbDocumentLoaderActions::setToolTip( const HbXmlVariable &tooltip )

{

    bool isWidget;

    QObject* obj = findFromStack(&isWidget);

    if( !obj || !isWidget ) {

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

        return false;

    }

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

    QVariant variant;

    bool result = variableToQVariant( tooltip, variant );

    if ( result ) {

        widget->setToolTip( variant.toString() );

    }

    return result;

}

bool HbDocumentLoaderActions::setSizePolicy(

    QSizePolicy::Policy *horizontalPolicy,

    QSizePolicy::Policy *verticalPolicy,

    int *horizontalStretch,

    int *verticalStretch )

{

    QGraphicsLayoutItem *current = findSpacerItemFromStackTop();

    if (!current) {

        bool isWidget = false;

        QObject* obj = findFromStack(&isWidget);

        if( !obj || !isWidget ) {

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

            return false;

        }

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

        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() ) ) {