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

**

** 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 HbCore 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 <QTranslator>

#if defined(Q_OS_SYMBIAN)

#include <e32base.h> 

#endif // Q_OS_SYMBIAN

#include "hbdntxmlreader_p.h"

#define DirectoryLocalizerFile ":/i18n/hbdirectorylocalizer.xml"

#define DirectoryLocalizerTranslationsFile "/resource/hbi18n/translations/directorylocalizer_"

HbDNTXmlReader::HbDNTXmlReader()

{

	fullPaths = NULL;

	pathStrings = NULL;

	parseDirectoryPaths = false; 

	parsePathStrings = false;

	elementNumber = 0;

	validElement = false;

	twoDone = false;

    QLocale locale = QLocale::system();

    trans = new QTranslator();

	QString languageStr;

	languageStr.append(DirectoryLocalizerTranslationsFile);

	languageStr.append(locale.name());

// Support for checking both Z and C drives 

#if defined(Q_OS_SYMBIAN)

	bool succeed = false;

	succeed = trans->load("z:" + languageStr);

	if ( succeed == false ) {

		trans->load("c:" + languageStr);

	}

#else // Q_OS_SYMBIAN

	trans->load(languageStr);

#endif // Q_OS_SYMBIAN

	QCoreApplication::installTranslator(trans);

	validElement = false;

	QFile xmlFile(DirectoryLocalizerFile);

	pathStrings = new QMap<QString, QString>;

	fullPaths = new QMap<QString,QString>;

	if( xmlFile.exists() )

		{

			QXmlInputSource source( &xmlFile );

			QXmlSimpleReader reader; 

			reader.setContentHandler( this );  

			reader.parse( source ) ;

		}

}

HbDNTXmlReader::~HbDNTXmlReader()

{

    delete fullPaths;

    delete pathStrings;

	QCoreApplication::removeTranslator(trans);

	delete trans;

}

bool HbDNTXmlReader::startDocument()

{

    return true;

}

bool HbDNTXmlReader::startElement( const QString & ,

				   const QString & ,

				   const QString & qName,

				   const QXmlAttributes & )

{

	if( qName == DirectoryLocalizerPathStringsStr ) {

		parsePathStrings = true;  // set to parse Path 

		parseDirectoryPaths = false;

		elements.clear();

		elementNumber = 0;  // Set current path element number as undefined

		twoDone = false;

	} else if( qName == DirectoryLocalizerFullDirectoryPathsStr ) {

		parsePathStrings = false;

		parseDirectoryPaths = true;  // set to parse localized path

		elements.clear();

		elementNumber = 0;  // set current path element as undefined

		twoDone = false;

	} else if( qName == DirectoryLocalizerNameStr ) {

		elementNumber = 1;  // 

		validElement = true;

		twoDone = false;

	} else if( qName == DirectoryLocalizerPathStr ){

		elementNumber = 2;

		validElement = true;

		twoDone = false;

	} else if( qName == DirectoryLocalizerTranslationStr){

		elementNumber = 3;

		validElement = true;	

	} else if( qName == DirectoryLocalizerRootPathStr ){

		elementNumber = 1;

		validElement = true;

		twoDone = false;

	} else if( qName == DirectoryLocalizerLocalizedPathStr ){

		elementNumber = 2;

		validElement = true;

		twoDone = false;

	} else if( qName == DirectoryLocalizerLocalizedNameStr ){

		elementNumber = 3;

		validElement = true;

		twoDone = false;

	} else

    {

        elementNumber++;

    }

    return true;	

}

bool HbDNTXmlReader::characters(const QString& text)

{

    QString t = text;

    QString x;

    QString y;

    QString localizedStr;

    QString path;

    char* charPtr(NULL); 

    QByteArray* ba(NULL);

    if(validElement && elementNumber == 3 ) {

        ba = new QByteArray(t.toAscii());

        charPtr = ba->data();

    }

    if( validElement ) {

		if(parsePathStrings) {

			switch(elementNumber) {

            case 1:  // DirectoryLocalizerNameStr     

                t=t.toLower();

                elements.insert(0,t);

                break;

            case 2:  // DirectoryLocalizerPathStr  

                t= t.replace(DirectoryLocalizerDirectorySeparatorX2,DirectoryLocalizerDirectorySeparatorX1);					

                t=t.toLower();

                if ( elements.count() > 1 ) {

                    elements.insert(1,t);

                } else { 

                    elements.append(t);

                }

                break;

            case 3:  // DirectoryLocalizerTranslationStr 			

                elements.insert(0,t);

                localizedStr = QCoreApplication::translate(0,charPtr);

                delete ba;

                if( localizedStr == t ){

					localizedStr = "";                

                }

                elements.append(localizedStr);

                break;

            default:

                elements.append(t); 

                break;

            }

            validElement = false;    	

		} else if(parseDirectoryPaths) {			

			switch(elementNumber) {

            case 1: // DirectoryLocalizerRootPathStr

                temp = t;

                break;

            case 2: // DirectoryLocalizerLocalizedPathStr							

                x = pathStrings->value(temp);

                y = pathStrings->value(t);

                path.append( x );

                path.append( y );

                elements.insert(0,path);

                break;

            case 3: // DirectoryLocalizerLocalizedNameStr

                 x = pathStrings->value(t);

                 elements.insert(1, x);

                break;

            default:			

                break;

			}

			validElement = false;    				

		}

	}

    return true;

}

bool HbDNTXmlReader::endElement( const QString &,

        const QString &,

        const QString & qName )

{

	if( qName == DirectoryLocalizerPathStringsStr ) {

		parsePathStrings = false;

		parseDirectoryPaths = false;

		elements.clear();

		elementNumber = 0;

	} else if( qName == DirectoryLocalizerFullDirectoryPathsStr ) {

		parsePathStrings = false;

		parseDirectoryPaths = false;

		elements.clear();

		elementNumber = 0;

	}

	if( parsePathStrings && elements.count() > 1 ) {

        pathStrings->insertMulti(elements.at(0), elements.at(1));

        elements.clear();		

    } else if(parseDirectoryPaths && elements.count() > 1) {

		QString element1, element2;

		switch(elements.count()) {				

        case 2:					

            if(!twoDone){

                fullPaths->insertMulti(elements.at(0),elements.at(1));

                twoDone = true;

                elements.clear();

            }

            break;

        default:

            break;

		}

	}

	return true;

}

bool HbDNTXmlReader::endDocument()

{

    return true;

}

QMap<QString,QString> HbDNTXmlReader::getFullPaths()

{

	return *fullPaths;

}