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

**

** 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;

    }

    QObject *current = lookUp(type, name).mObject.data();

    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);

    QObject *current = item.mObject.data();

    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);

    if (item.mType == HbXml::WIDGET) {

        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::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 ].mObject;

    if( !src ) {

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

        return false;

    }

    QObject *dst = mObjectMap[ dstName ].mObject;

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

    QObject *ref = mObjectMap[ name ].mObject.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::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)

{

    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);

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

            widget->setMinimumWidth(hintWidthVal);

        }

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

            widget->setMinimumHeight(hintHeightVal);

        }

        break;

    case Qt::PreferredSize:

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

            widget->setPreferredWidth(hintWidthVal);

        }

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

            widget->setPreferredHeight(hintHeightVal);

        }

        break;

    case Qt::MaximumSize:

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

            widget->setMaximumWidth(hintWidthVal);

        }

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

            widget->setMaximumHeight(hintHeightVal);

        }

        break;

    default:

        break;

    }

    if (fixed) {

        QSizePolicy policy = widget->sizePolicy();

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

            policy.setHorizontalPolicy(QSizePolicy::Fixed);

        }

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

            policy.setVerticalPolicy(QSizePolicy::Fixed);

        }

        widget->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 )

{

    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);

    bool changed = false;

    QSizePolicy sizePolicy = widget->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 ) {

        widget->setSizePolicy( sizePolicy );

    }

    return true;

}

bool HbDocumentLoaderActions::createAnchorLayout( const QString &widget, bool modify )

{

    QGraphicsWidget *parent = 0;

    if( widget.isEmpty() ) {

        bool isWidget = false;

        QObject *parentObj = findFromStack( &isWidget );

        if( isWidget ) {

            parent = static_cast<QGraphicsWidget *>( parentObj );

        }

    } else if ( mObjectMap.contains( widget ) && mObjectMap[ widget ].mType == HbXml::WIDGET ) {

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

    }

    if ( !parent ) {

        HB_DOCUMENTLOADER_PRINT( QString( "ANCHORLAYOUT: PARENT NOT FOUND" ) );

        return false;

    }

    if ( modify ) {

        mCurrentLayout = parent->layout();

        if ( !mCurrentLayout ) {

            HB_DOCUMENTLOADER_PRINT( QString( "ANCHORLAYOUT: NO EXISTING LAYOUT" ) );

            return false;

        }

    } else {

        mCurrentLayout = new HbAnchorLayout();

        parent->setLayout( mCurrentLayout );

    }

    return true;

}

bool HbDocumentLoaderActions::addAnchorLayoutItem( const QString &src, const QString &srcId, Hb::Edge srcEdge, 

                                                   const QString &dst, const QString &dstId, Hb::Edge dstEdge,