/*

* Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  

 *

*/

#include <bautils.h>

//#include <mnaiwservices.h>

#include <liwservicehandler.h>

#include <e32hashtab.h>

#include <eikenv.h> 

#include "hnutils.h"

#include "hnliwutils.h"

#include "hnmdservicecommand.h"

#include "hnservicehandler.h"

#include "hnglobals.h"

#include "hnmdbasekey.h"

#include "menudebug.h"

#include "hnconvutils.h"

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//

EXPORT_C HBufC8* HnUtils::ReadFileLC(const TDesC& aPath)

    {

    RFs& fs = CEikonEnv::Static()->FsSession();

    RFile file;

    User::LeaveIfError( file.Open(fs, aPath, EFileRead) );

    CleanupClosePushL( file );

    TInt fileSize(0);

    User::LeaveIfError( file.Size( fileSize ) );

    HBufC8* buf = HBufC8::NewLC( fileSize );

    TPtr8 bufPtr( buf->Des() );

    User::LeaveIfError( file.Read( bufPtr ) );

    // clean up

    CleanupStack::Pop(buf);

    CleanupStack::PopAndDestroy(&file);

    CleanupStack::PushL(buf);

    return buf;

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//

EXPORT_C HBufC8* HnUtils::ReadFileL( const TDesC& aPath )

    {

    HBufC8* buf = ReadFileLC( aPath );

    CleanupStack::Pop( buf );

    return buf;

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//      

EXPORT_C HBufC* HnUtils::LocateFileLC( const TDesC& aFile )

    {

    HBufC* filePath = HBufC::NewLC(KMaxName);

    RFs& fs = CEikonEnv::Static()->FsSession();

    TDriveList driveList;

    TChar driveLetter;

    TInt driveNumber=EDriveY;

    User::LeaveIfError(fs.DriveList(driveList));

    for(; driveNumber>=EDriveA-1; driveNumber-- )

        {

        if (driveNumber==EDriveA-1)

        driveNumber = EDriveZ;

        if (driveList[driveNumber])

            {

            User::LeaveIfError(fs.DriveToChar(driveNumber, driveLetter));

            filePath->Des().Zero();

            filePath->Des().Append(driveLetter);

            filePath->Des().Append(KRscPath);

            filePath->Des().Append(aFile);

            if (BaflUtils::FileExists(fs,*filePath))

                {

                return filePath;

                }

            }

        if (driveNumber == EDriveZ)

        break;

        }

    User::Leave(KErrNotFound);

    return filePath;

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//      

EXPORT_C HBufC* HnUtils::LocateNearestLanguageFileLC( const TDesC& aFile )

    {

    _LIT( KExtRSC, ".r");

    if (aFile.Find( KExtRSC ) == (aFile.Length() - 4) )

        {

        HBufC* filePath = HBufC::NewLC(KMaxName);

        RFs& fs = CEikonEnv::Static()->FsSession();

        TDriveList driveList;

        TChar driveLetter;

        TInt driveNumber=EDriveY;

        User::LeaveIfError(fs.DriveList(driveList));

        TFileName file;

        for(; driveNumber>=EDriveA-1; driveNumber-- )

            {

            if (driveNumber==EDriveA-1)

            driveNumber = EDriveZ;

            if (driveList[driveNumber])

                {

                User::LeaveIfError(fs.DriveToChar(driveNumber, driveLetter));

                filePath->Des().Zero();

                filePath->Des().Append(driveLetter);

                filePath->Des().Append(KRscPath);

                filePath->Des().Append(aFile);

                file = *filePath;

                BaflUtils::NearestLanguageFile( fs, file);

                if( BaflUtils::FileExists( fs, file))

                    {

                    CleanupStack::PopAndDestroy(filePath);    

                    return file.AllocLC();

                    }

                }

            if (driveNumber == EDriveZ)

            break;

            }

        CleanupStack::PopAndDestroy(filePath);

        }

    return KNullDesC().AllocLC();

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

// 

EXPORT_C void HnUtils::SetAttributeL( const TXmlEngElement& aElement,

        RBuf8& aAttribute )

    {

    TPtrC8 v = aElement.Value();

    if ( v.Length()> 0 )

        {

        HBufC8* trimmed = v.AllocLC();

        trimmed->Des().Trim();

        aAttribute.Close();

        aAttribute.CreateL( trimmed->Length() );

        aAttribute.Copy( *trimmed );

        CleanupStack::PopAndDestroy( trimmed );

        }

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

// 

EXPORT_C void HnUtils::SetAttributeL( const TXmlEngElement& aElement,

        const TDesC8& aAttributeName, RBuf8& aValue8 )

    {

    if ( aElement.HasAttributeL( aAttributeName ) )

        {

        TPtrC8 value8 =

        aElement.AttributeNodeL( aAttributeName ).Value();

        aValue8.Close();

        aValue8.CreateL( value8.Length() );

        aValue8.Copy( value8 );

        }

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

// 

EXPORT_C HBufC8 * HnUtils::GetColumnTextLC( TInt aColumn,

        const TDesC8 & aSourceText, TChar aColumnSeparator )

    {

    HBufC8 * ret = NULL;

    TLex8 processedText ( aSourceText );

    TInt column( 0 );

    processedText.Mark();

    while ( !processedText.Eos() )

        {

        if ( processedText.Get() == aColumnSeparator )

            {

            if ( column == aColumn )

                {

                processedText.UnGet();

                break;

                }

            processedText.Mark();

            column++;

            }

        }

    if ( aColumn <= column )

        {

        ret = processedText.MarkedToken().AllocLC();

        }

    return ret;

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

// 

EXPORT_C TInt HnUtils::GetColumnTextColumnCount(

        const TDesC8 & aSourceText, TChar aColumnSeparator )

    {

    TInt ret(1);

    TLex8 processedText(aSourceText);

    while ( !processedText.Eos() )

        {

        if (processedText.Get() == aColumnSeparator)

            {

            ret++;

            }

        }

    return ret;

    }