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

**

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

#include <QMetaEnum>

#include <QTranslator>

#include <QDataStream>

#include <QDebug>

// Document loader version number

#define VERSION_MAJOR 1

#define VERSION_MINOR 1

#define MIN_SUPPORTED_VERSION_MAJOR 0

#define MIN_SUPPORTED_VERSION_MINOR 1

//#define LINE_DEBUGGING

#ifdef LINE_DEBUGGING

#include <QTime>

static QTime lineDebugTime;

#ifdef Q_OS_SYMBIAN

#include <e32debug.h>

#endif

void doDebugPrint(const char* text)

{

#ifdef Q_OS_SYMBIAN

    RDebug::Printf(text);

#else

    qDebug() << text;

#endif

}

// Takes standard c-format.

void debugPrint(const char* cformat, ...)

{

    va_list ap;

    va_start(ap, cformat);

    QString str = QString().vsprintf(cformat, ap);

    va_end(ap);

    doDebugPrint(str.toAscii().constData());

}

#endif // LINE_DEBUGGING

const char *ZValueProperty = "z";

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 HbDocumentLoaderSyntax

    \internal

    \proto

*/

HbDocumentLoaderSyntax::HbDocumentLoaderSyntax( HbXmlLoaderAbstractActions *actions )

: HbXmlLoaderBaseSyntax( actions )

{

}

HbDocumentLoaderSyntax::~HbDocumentLoaderSyntax()

{

}

bool HbDocumentLoaderSyntax::scanForSections( QIODevice *device, QList<QString> &sectionsList )

{

#ifdef LINE_DEBUGGING

    lineDebugTime.restart();

    debugPrint("MYTRACE: DocML scanForSections, start");

#endif

    bool ret = HbXmlLoaderBaseSyntax::scanForSections( device, sectionsList );

#ifdef LINE_DEBUGGING

    debugPrint("MYTRACE: DocML scanForSections, end: %d", lineDebugTime.elapsed());

#endif

    return ret;

}

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

{

#ifdef LINE_DEBUGGING

    lineDebugTime.restart();

    debugPrint("MYTRACE: DocML load, start");

#endif

    bool ret = HbXmlLoaderBaseSyntax::loadDevice( device, section );

#ifdef LINE_DEBUGGING

    debugPrint("MYTRACE: DocML load, end: %d", lineDebugTime.elapsed());

#endif

    return ret;

}

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 srcEdgeStr = attribute( AL_SRC_EDGE );

                const QString dstEdgeStr = attribute( AL_DST_EDGE );

                const QString spacing = attribute( AL_SPACING );

                const QString spacer = attribute( AL_SPACER );

                HbXmlLengthValue spacingVal;

                result = true;

                if( !spacing.isEmpty() ) {

                    result = toLengthValue( spacing, spacingVal );

                }

                Hb::Edge srcEdge, dstEdge;

                result &= getAnchorEdge( srcEdgeStr, srcEdge );

                result &= getAnchorEdge( dstEdgeStr, dstEdge );

                if ( result ) {

                    result = mActions->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 );

                int rownum = row.toInt( &result );

                if (!result) {

                    HB_DOCUMENTLOADER_PRINT( QString( "GRIDLAYOUT: NO ROW SPECIFIED" ) );

                    break;

                }

                int columnnum = column.toInt( &result );

                if (!result) {

                    HB_DOCUMENTLOADER_PRINT( QString( "GRIDLAYOUT: NO COLUMN SPECIFIED" ) );

                    break;

                }

                int rowspannum;

                int *rowspan_p = 0;

                if (!rowspan.isEmpty()) {

                    rowspannum = rowspan.toInt( &result );

                    if (!result) {

                        HB_DOCUMENTLOADER_PRINT( QString( "GRIDLAYOUT: INVALID ROWSPAN" ) );

                        break;

                    } else {

                        rowspan_p = &rowspannum;

                    }

                }

                int columnspannum;

                int *columnspan_p = 0;

                if (!columnspan.isEmpty()) {

                    columnspannum = columnspan.toInt( &result );

                    if (!result) {

                        HB_DOCUMENTLOADER_PRINT( QString( "GRIDLAYOUT: INVALID ROWSPAN" ) );

                        break;

                    } else {

                        columnspan_p = &columnspannum;

                    }

                }

                Qt::Alignment align;

                Qt::Alignment *align_p = 0;

                if (!alignment.isEmpty()) {

                    AccessToMetadata myAccess;

                    int value = myAccess.getEnumValue( "Alignment", alignment.toLatin1().data() );

                    if (value == -1) {

                        HB_DOCUMENTLOADER_PRINT( QString( "GRIDLAYOUT: NO SUCH ALIGNMENT " ) + alignment );

                        result = false;

                        break;

                    } else {

                        align = (Qt::Alignment)value;

                        align_p = &align;

                    }

                }

                result = mActions->addGridLayoutCell( src, rownum, columnnum, rowspan_p, columnspan_p, align_p );

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

                const int rownum = row.toInt( &result );

                if (!result) {

                    HB_DOCUMENTLOADER_PRINT( QString( "GRIDLAYOUT: NO ROW NUMBER SPECIFIED FOR STRETCH FACTOR" ) );

                    break;

                }

                int stretchnum;

                int *stretch_p = 0;

                if( !stretchfactor.isEmpty() ) {

                    stretchnum = stretchfactor.toInt( &result );

                    if (!result) {

                        HB_DOCUMENTLOADER_PRINT( QString( "GRIDLAYOUT: UNABLE TO PARSE ROW STRETCH FACTOR VALUE" ) );

                        break;

                    } else {

                        stretch_p = &stretchnum;

                    }

                }

                Qt::Alignment align;

                Qt::Alignment *align_p = 0;

                if( !alignment.isEmpty() ) {

                    AccessToMetadata myAccess;

                    int value = myAccess.getEnumValue( "Alignment", alignment.toLatin1().data() );

                    if( value == -1 ) {

                        HB_DOCUMENTLOADER_PRINT( QString( "GRIDLAYOUT: NO SUCH ROW ALIGNMENT " ) + alignment );

                        result = false;

                        break;

                    } else {

                        align = (Qt::Alignment)value;

                        align_p = &align;

                    }

                }

                result = mActions->setGridLayoutRowProperties( rownum, stretch_p, align_p );

                if (result) {

                    result = processRowHeights( rownum );

                }

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

                const int columnnum = column.toInt( &result );

                if (!result) {

                    HB_DOCUMENTLOADER_PRINT( QString( "GRIDLAYOUT: NO COLUMN NUMBER SPECIFIED FOR STRETCH FACTOR" ) );

                    break;

                }

                int stretchnum;

                int *stretch_p = 0;

                if (!stretchfactor.isEmpty()) {

                    stretchnum = stretchfactor.toInt( &result );

                    if (!result) {

                        HB_DOCUMENTLOADER_PRINT( QString( "GRIDLAYOUT: UNABLE TO PARSE COLUMN STRETCH FACTOR VALUE" ) );

                        break;

                    } else {

                        stretch_p = &stretchnum;

                    }

                }

                Qt::Alignment align;

                Qt::Alignment *align_p = 0;

                if (!alignment.isEmpty()) {

                    AccessToMetadata myAccess;

                    int value = myAccess.getEnumValue( "Alignment", alignment.toLatin1().data() );

                    if (value == -1) {

                        HB_DOCUMENTLOADER_PRINT( QString( "GRIDLAYOUT: NO SUCH COLUMN ALIGNMENT " ) + alignment );

                        result = false;

                        break;

                    } else {

                        align = (Qt::Alignment)value;

                        align_p = &align;

                    }

                }

                result = mActions->setGridLayoutColumnProperties( columnnum, stretch_p, align_p );

                if (result) {

                    result = processColumnWidths( columnnum );

                }

            } 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 itemname = attribute( LL_ITEMNAME );

                const QString index = attribute( LL_INDEX );

                const QString stretchfactor = attribute( ATTR_STRETCHFACTOR );

                const QString alignment = attribute( TYPE_ALIGNMENT );

                const QString spacing = attribute( LL_SPACING );

                int indexnum;

                int *index_p = 0;

                if (!index.isEmpty()) {

                    indexnum = index.toInt( &result );

                    if (!result) {

                        HB_DOCUMENTLOADER_PRINT( QString( "LINEARLAYOUT: UNABLE TO PARSE ITEM INDEX" ) );

                        break;

                    } else {

                        index_p = &indexnum;

                    }

                }

                int stretchnum;

                int *stretch_p = 0;

                if (!stretchfactor.isEmpty()) {

                    stretchnum = stretchfactor.toInt( &result );

                    if (!result) {

                        HB_DOCUMENTLOADER_PRINT( QString( "LINEARLAYOUT: UNABLE TO PARSE STRETCH VALUE" ) );

                        break;

                    } else {

                        stretch_p = &stretchnum;

                    }

                }

                Qt::Alignment align;

                Qt::Alignment *align_p = 0;

                if (!alignment.isEmpty()) {

                    AccessToMetadata myAccess;

                    int value = myAccess.getEnumValue( "Alignment", alignment.toLatin1().data() );

                    if (value == -1) {

                        HB_DOCUMENTLOADER_PRINT( QString( "LINEARLAYOUT: NO SUCH ITEM ALIGNMENT " ) + alignment );

                        result = false;

                        break;

                    } else {

                        align = (Qt::Alignment)value;

                        align_p = &align;

                    }

                }

                HbXmlLengthValue spacingValue;

                if (!spacing.isEmpty()) {

                    result = toLengthValue( spacing, spacingValue );

                }

                if (result) {

                    result = mActions->addLinearLayoutItem( itemname, index_p, stretch_p, align_p, spacingValue );

                }

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

                const QString index = attribute( LL_INDEX );

                const QString stretchfactor = attribute( ATTR_STRETCHFACTOR );

                int indexnum;

                int *index_p = 0;

                if (!index.isEmpty()) {

                    indexnum = index.toInt( &result );

                    if (!result) {

                        HB_DOCUMENTLOADER_PRINT( QString( "LINEARLAYOUT: UNABLE TO PARSE STRETCH INDEX" ) );

                        break;

                    } else {

                        index_p = &indexnum;

                    }

                }

                int stretchnum;

                int *stretch_p = 0;

                if (!stretchfactor.isEmpty()) {

                    stretchnum = stretchfactor.toInt( &result );

                    if (!result) {

                        HB_DOCUMENTLOADER_PRINT( QString( "LINEARLAYOUT: UNABLE TO PARSE STRETCH VALUE" ) );

                        break;

                    } else {

                        stretch_p = &stretchnum;

                    }

                }

                result = mActions->addLinearLayoutStretch( index_p, stretch_p );

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

                int indexnum;

                int *index_p = 0;

                if( !index.isEmpty() ) {

                    indexnum = index.toInt( &result );

                    if( !result ) {

                        HB_DOCUMENTLOADER_PRINT( QString( "STACKEDLAYOUT: UNABLE TO PARSE ITEM INDEX" ) );

                        break;

                    } else {

                        index_p = &indexnum;

                    }

                }

                result = mActions->addStackedLayoutItem( itemname, index_p );

            }

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

        }

    }

#ifdef LINE_DEBUGGING

    debugPrint("MYTRACE: --- after line %d, time: %d", (int)mReader.lineNumber(), lineDebugTime.elapsed());

#endif

    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;

    HbXmlLengthValue left, top, right, bottom;

    if ( !leftS.isEmpty() ) {

        result = toLengthValue(leftS, left);

    }

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

        result = toLengthValue(topS, top);

    }

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

        result = toLengthValue(rightS, right);

    }

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

        result = toLengthValue(bottomS, bottom);

    }

    if ( result ) {

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

    }

    if (!result) {

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

    }

    return result;

}

bool HbDocumentLoaderSyntax::processRowHeights( int 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 );

    HbXmlLengthValue minHeight, maxHeight, prefHeight, fixedHeight, rowSpacing;

    bool result = true;

    if ( !minHeightS.isEmpty() ) {

        result = toLengthValue(minHeightS, minHeight);

    }

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

        result = toLengthValue(maxHeightS, maxHeight);

    }

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

        result = toLengthValue(prefHeightS, prefHeight);

    }