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

**

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

#include "hbdocumentloaderactions_p.h"

#include "hbdocumentloader_p.h"

#include "hbdocumentloader.h"

#include <hbicon.h>

#include <hbfontspec.h>

#include <QDebug>

#include <QMetaEnum>

#include <QTranslator>

#include <hbmainwindow.h>

// Document loader version number

#define VERSION_MAJOR 1

#define VERSION_MINOR 0

#define MIN_SUPPORTED_VERSION_MAJOR 0

#define MIN_SUPPORTED_VERSION_MINOR 1

/*

    \class HbDocumentLoaderSyntax

    \internal

    \proto

*/

HbDocumentLoaderSyntax::HbDocumentLoaderSyntax( HbDocumentLoaderActions *actions, const HbMainWindow *window )

: HbXmlLoaderAbstractSyntax( actions ), mRealActions( actions ), mMainWindow(window)

{

}

HbDocumentLoaderSyntax::~HbDocumentLoaderSyntax()

{

}

bool HbDocumentLoaderSyntax::load( QIODevice *device, const QString &section )

{

    mCurrentProfile = HbDeviceProfile::profile(mMainWindow);

    return HbXmlLoaderAbstractSyntax::loadDevice( device, section );

}

bool HbDocumentLoaderSyntax::readLayoutStartItem()

{

    bool result = false;

    switch( mCurrentLayoutType ) {

        case LAYOUT_ANCHOR:

        {

            HB_DOCUMENTLOADER_PRINT( "GENERAL LAYOUT START ITEM: ANCHOR ITEM" );

            if( mReader.name() == lexemValue( AL_ANCHOR ) ) {

                const QString src = attribute( AL_SRC_NAME );

                const QString dst = attribute( AL_DST_NAME );

                const QString srcEdge = attribute( AL_SRC_EDGE );

                const QString dstEdge = attribute( AL_DST_EDGE );

                const QString spacing = attribute( AL_SPACING );

                const QString spacer = attribute( AL_SPACER );

                qreal spacingVal = 0;

                result = true;

                if( !spacing.isEmpty() ) {

                    result = toPixels( spacing, spacingVal );

                }

                if (result) {

                    result = mRealActions->addAnchorLayoutEdge( src, srcEdge, dst, dstEdge, spacingVal, spacer );

                }

            }

            break;

        }

        case LAYOUT_GRID:

        {

            HB_DOCUMENTLOADER_PRINT( "GENERAL LAYOUT START ITEM: GRID ITEM" );

            if( mReader.name() == lexemValue( GL_GRIDCELL ) ) {

                const QString src = attribute( GL_ITEMNAME );

                const QString row = attribute( GL_ROW );

                const QString column = attribute( GL_COLUMN );

                const QString rowspan = attribute( GL_ROWSPAN );

                const QString columnspan = attribute( GL_COLUMNSPAN );

                const QString alignment = attribute( TYPE_ALIGNMENT );

                result = mRealActions->addGridLayoutCell( src, row, column, rowspan, columnspan, alignment );

            } else if( mReader.name() == lexemValue( GL_GRIDROW ) ) {

                const QString row = attribute( GL_ROW );

                const QString stretchfactor = attribute( ATTR_STRETCHFACTOR );

                const QString alignment = attribute( TYPE_ALIGNMENT );

                result = mRealActions->setGridLayoutRowProperties( row, stretchfactor, alignment );

                if (result) {

                    result = processRowHeights( row );

                }

            } else if( mReader.name() == lexemValue( GL_GRIDCOLUMN ) ) {

                const QString column = attribute( GL_COLUMN );

                const QString stretchfactor = attribute( ATTR_STRETCHFACTOR );

                const QString alignment = attribute( TYPE_ALIGNMENT );

                result = mRealActions->setGridLayoutColumnProperties( column, stretchfactor, alignment );

                if (result) {

                    result = processColumnWidths( column );

                }

            } else if( mReader.name() == lexemValue( TYPE_CONTENTSMARGINS ) ) {

                result = processContentsMargins();

            }

            break;

        }

        case LAYOUT_LINEAR:

        {

            HB_DOCUMENTLOADER_PRINT( "GENERAL LAYOUT START ITEM: LINEAR ITEM" );

            if( mReader.name() == lexemValue( LL_LINEARITEM ) ) {

                result = true;

                const QString index = attribute( LL_INDEX );

                const QString itemname = attribute( LL_ITEMNAME );

                const QString spacing = attribute( LL_SPACING );

                const QString stretchfactor = attribute( ATTR_STRETCHFACTOR );

                const QString alignment = attribute( TYPE_ALIGNMENT );

                qreal spacingValue(0);

                qreal *spacingPtr(0);

                if( !spacing.isEmpty() ) {

                    result = toPixels( spacing, spacingValue );

                    spacingPtr = &spacingValue;

                }

                if (result) {

                    result = mRealActions->addLinearLayoutItem( itemname, index, stretchfactor, alignment, spacingPtr );

                }

            } else if( mReader.name() == lexemValue( LL_STRETCH ) ) {

                const QString index = attribute( LL_INDEX );

                const QString stretchfactor = attribute( ATTR_STRETCHFACTOR );

                result = mRealActions->addLinearLayoutStretch( index, stretchfactor );

            } else if( mReader.name() == lexemValue( TYPE_CONTENTSMARGINS ) ) {

                result = processContentsMargins();

            }

            break;

        }

        case LAYOUT_STACK:

        {

            HB_DOCUMENTLOADER_PRINT( "GENERAL LAYOUT START ITEM: STACK ITEM" );

            if( mReader.name() == lexemValue( SL_STACKITEM ) ) {

                const QString index = attribute( SL_INDEX );

                const QString itemname = attribute( SL_ITEMNAME );

                result =  mRealActions->addStackedLayoutItem( itemname, index );

            }

            break;

        }

        case LAYOUT_NULL:

        {

            HB_DOCUMENTLOADER_PRINT( "GENERAL LAYOUT START ITEM: NULL ITEM (MUST NOT EXIST)" );

            break;

        }

        default:

        {

            qWarning() << "Internal error, wrong layout type, line " << mReader.lineNumber();

        }

    }

    return result;

}

bool HbDocumentLoaderSyntax::processContentsMargins()

{

    const QString leftS = attribute( ATTR_LEFT );

    const QString topS = attribute( ATTR_TOP );

    const QString rightS = attribute( ATTR_RIGHT );

    const QString bottomS = attribute( ATTR_BOTTOM );

    bool result = true;

    qreal left = 0, top = 0, right = 0, bottom = 0;

    if ( !leftS.isEmpty() ) {

        result = toPixels(leftS, left);

    }

    if ( result && !topS.isEmpty() ) {

        result = toPixels(topS, top);

    }

    if ( result && !rightS.isEmpty() ) {

        result = toPixels(rightS, right);

    }

    if ( result && !bottomS.isEmpty() ) {

        result = toPixels(bottomS, bottom);

    }

    if ( result ) {

        result = mRealActions->setLayoutContentsMargins( left, top, right, bottom );

    }

    if (!result) {

        qWarning() << "Invalid contents margins, line " << mReader.lineNumber();

    }

    return result;

}

bool HbDocumentLoaderSyntax::processRowHeights( const QString &row )

{

    const QString minHeightS = attribute( GL_MINHEIGHT );

    const QString maxHeightS = attribute( GL_MAXHEIGHT );

    const QString prefHeightS = attribute( GL_PREFHEIGHT );

    const QString fixedHeightS = attribute( GL_FIXEDHEIGHT );

    const QString rowSpacingS = attribute( GL_SPACING );

    qreal minHeight = -1;

    qreal maxHeight = -1;

    qreal prefHeight = -1;

    qreal fixedHeight = -1;

    qreal rowSpacing = -1;

    bool result = true;

    int propertyAvailable = 0;

    if ( !minHeightS.isEmpty() ) {

        result = toPixels(minHeightS, minHeight);

        propertyAvailable |= HbDocumentLoaderActions::propertyMin;

    }

    if ( result && !maxHeightS.isEmpty() ) {

        result = toPixels(maxHeightS, maxHeight);

        propertyAvailable |= HbDocumentLoaderActions::propertyMax;

    }

    if ( result && !prefHeightS.isEmpty() ) {

        result = toPixels(prefHeightS, prefHeight);

        propertyAvailable |= HbDocumentLoaderActions::propertyPref;

    }

    if ( result && !fixedHeightS.isEmpty() ) {

        result = toPixels(fixedHeightS, fixedHeight);

        propertyAvailable |= HbDocumentLoaderActions::propertyFixed;

    }

    if ( result && !rowSpacingS.isEmpty() ) {

        result = toPixels(rowSpacingS, rowSpacing);

        propertyAvailable |= HbDocumentLoaderActions::propertySpacing;

    }

    if ( result && propertyAvailable ) {

        result = mRealActions->setGridLayoutRowHeights( row, minHeight, maxHeight, 

                                                        prefHeight, fixedHeight, 

                                                        rowSpacing, propertyAvailable);

    }

    return result;

}

bool HbDocumentLoaderSyntax::processColumnWidths( const QString &column )

{

    const QString minWidthS = attribute( GL_MINWIDTH );

    const QString maxWidthS = attribute( GL_MAXWIDTH );

    const QString prefWidthS = attribute( GL_PREFWIDTH );

    const QString fixedWidthS = attribute( GL_FIXEDWIDTH );

    const QString columnSpacingS = attribute( GL_SPACING );

    qreal minWidth = -1;

    qreal maxWidth = -1;

    qreal prefWidth = -1;

    qreal fixedWidth = -1;

    qreal columnSpacing = -1;

    bool result = true;

    int propertyAvailable = 0;

    if ( !minWidthS.isEmpty() ) {

        result = toPixels(minWidthS, minWidth);

        propertyAvailable |= HbDocumentLoaderActions::propertyMin;

    }

    if ( result && !maxWidthS.isEmpty() ) {

        result = toPixels(maxWidthS, maxWidth);

        propertyAvailable |= HbDocumentLoaderActions::propertyMax;

    }

    if ( result && !prefWidthS.isEmpty() ) {

        result = toPixels(prefWidthS, prefWidth);

        propertyAvailable |= HbDocumentLoaderActions::propertyPref;

    }

    if ( result && !fixedWidthS.isEmpty() ) {

        result = toPixels(fixedWidthS, fixedWidth);

        propertyAvailable |= HbDocumentLoaderActions::propertyFixed;

    }

    if ( result && !columnSpacingS.isEmpty() ) {

        result = toPixels(columnSpacingS, columnSpacing);

        propertyAvailable |= HbDocumentLoaderActions::propertySpacing;

    }

    if ( result && propertyAvailable ) {

        result = mRealActions->setGridLayoutColumnWidths( column, minWidth, maxWidth, 

                                                          prefWidth, fixedWidth, 

                                                          columnSpacing, propertyAvailable);

    }

    return result;

}

bool HbDocumentLoaderSyntax::readContainerStartItem()

{

    bool result = false;

    switch ( mCurrentElementType ) {

         case PROPERTY:

         {

            HB_DOCUMENTLOADER_PRINT( "CONTAINER START ITEM: PROPERTY" );

            switch( mCurrentContainerType ) {

                case CONTAINER_STRINGLIST:

                {

                    // check that we are only trying to put strings into a string list

                    HB_DOCUMENTLOADER_PRINT( "GENERAL CONTAINER START ITEM: STRING LIST" );

                    if( mReader.name() == lexemValue( TYPE_STRING )

                        || mReader.name() == lexemValue( TYPE_ENUMS )

                        || mReader.name() == lexemValue( TYPE_LOCALIZED_STRING ) ) {

                        result = processContainedProperty();

                        }

                    break;

                }

                case CONTAINER_NULL:

                {

                    HB_DOCUMENTLOADER_PRINT( "GENERAL CONTAINER START ITEM: NULL ITEM (MUST NOT EXIST)" );

                    break;

                }

                default:

                {

                    qWarning() << "Internal error, wrong container type, line " << mReader.lineNumber();

                    break;

                }

            }

            break;

         }

         default:

         {

             break;

         }

    }

    return result;

}

bool HbDocumentLoaderSyntax::readContainerEndItem()

{

    bool result = false;

    QString currentPropertyName;

    QVariant variant;

    switch( mCurrentElementType ) {

        case CONTAINER:

        {

            currentPropertyName = mCurrentContainer.back();

            mCurrentContainer.removeLast();

            if (mRealActions->mCurrentContainer) {

                // in order for the conversion to work, all of the contained types need to be suitable and equivalent, e.g. strings

                QVariant variantContainer = QVariant(*(mRealActions->mCurrentContainer));

                if (variantContainer.isValid()) {

                    switch(mCurrentContainerType) {

                        case CONTAINER_STRINGLIST:

                        {

                            QStringList list = variantContainer.toStringList();

                            variant = QVariant(list);

                            break;

                        }

                        default:

                        {

                            variant = variantContainer;

                            break;

                        }

                    }

                }

            }

            result = mRealActions->pushProperty(currentPropertyName, variant);

            HB_DOCUMENTLOADER_PRINT( "CONTAINER END ITEM : SWITCHING TO GENERAL ITEM PROCESSING MODE" );

            mElementState = ES_GENERAL_ITEM;

            result = true;

            break;

        }

        default:

        {

            result = HbXmlLoaderAbstractSyntax::readGeneralEndItem();

            break;

        }

    }

    return result;

}

bool HbDocumentLoaderSyntax::readGeneralStartItem()

{

    bool result = false;

    switch( mCurrentElementType ) {

         case OBJECT:

         {

            HB_DOCUMENTLOADER_PRINT( "GENERAL START ITEM: OBJECT" );

            result = processObject();

            break;

         }

         case WIDGET:

         {

            HB_DOCUMENTLOADER_PRINT( "GENERAL START ITEM: WIDGET" );

            result = processWidget();

            break;

         }

         case SPACERITEM:

         {

            HB_DOCUMENTLOADER_PRINT( "GENERAL START ITEM: SPACERITEM" );

            result = processSpacerItem();

            break;

         }

         case CONNECT:

         {

            HB_DOCUMENTLOADER_PRINT( "GENERAL START ITEM: CONNECT" );

            result = processConnect();

            break;

         }

         case PROPERTY:

         {

            HB_DOCUMENTLOADER_PRINT( "GENERAL START ITEM: PROPERTY" );

            result = processProperty();

            break;

         }

         case REF:

         {

            HB_DOCUMENTLOADER_PRINT( "GENERAL START ITEM: REF" );

            result = processRef();

            break;

         }

         case VARIABLE:

         {

            HB_DOCUMENTLOADER_PRINT( "GENERAL START ITEM: VARIABLE" );

            result = processVariable();

            break;

         }

         case DEPRECATED:

         {

             HB_DOCUMENTLOADER_PRINT( "GENERAL START ITEM: DEPRECATED" );

             result = true;

             break;

         }

         default:

         {

              result = HbXmlLoaderAbstractSyntax::readGeneralStartItem();

         }

    }

    return result;

}

bool HbDocumentLoaderSyntax::processDocument()

{

    bool ok, ok1, ok2, res = true;

    QString ver_str =  attribute( ATTR_VERSION );

    ver_str.toDouble( &ok );

    QStringList ver = ver_str.split( '.' );

    if( ( !ok ) || ( ver.size() != 2 ) ) {

        qWarning() << "Wrong document version format " << mReader.lineNumber();

        return false;

    }

    int major = ver.at(0).toInt( &ok1 );

    int minor = ver.at(1).toInt( &ok2 );

    if( ( !ok1 ) || ( !ok2 ) ) {

        qWarning() << "Wrong document version format " << mReader.lineNumber();

        return false;

    }

    if( ( major > VERSION_MAJOR ) || ( major < MIN_SUPPORTED_VERSION_MAJOR ) ) {

        res = false;

    } else if( ( ( major == VERSION_MAJOR ) && ( minor > VERSION_MINOR )  ) ||

               ( ( major == MIN_SUPPORTED_VERSION_MAJOR ) && ( minor < MIN_SUPPORTED_VERSION_MINOR ) ) ) {

        res = false;

    }

    if( ! res ) {

        qWarning() << "Not supported document version " + ver_str + ". Current parser version is: " + version();

        return false;

    }

    return mRealActions->pushDocument( attribute( ATTR_CONTEXT ) );

}

bool HbDocumentLoaderSyntax::processObject()

{

    const QString type = attribute( ATTR_TYPE );

    const QString name = attribute( ATTR_NAME );

    if( !mRealActions->pushObject( type, name ) ) {

        qWarning() << "Error in object processing, line " << mReader.lineNumber();

        return false;

    }

    return true;

}

bool HbDocumentLoaderSyntax::processWidget()

{

    const QString type = attribute( ATTR_TYPE );

    const QString name = attribute( ATTR_NAME );

    const QString role = attribute( ATTR_ROLE );

    const QString plugin = attribute( ATTR_PLUGIN );

    if( !mRealActions->pushWidget( type, name, role, plugin) ) {

        qWarning() << "Error in widget processing, line " << mReader.lineNumber();

        return false;

    }