/*

* Copyright (c) 2006-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:  Tfx parser.

*

*/

#include <TfxSrvEcomIds.h>

#include <f32file.h>

#include "tfxconfigparser.h"

_LIT8(KMimetype,"text/xml");

_LIT8(KManifestTag, "mf");

_LIT8(KSelTag,"sel");

_LIT8(KBaseSkinTag, "baseskin");

_LIT8(KEffectNameTag, "name");

_LIT8(KEffectFileTag, "file");

_LIT8(KEffectDefinitionsTag, "effectdefinitions");

_LIT8(KEffectTag, "effect");

_LIT8(KEffectWantedTimeTag, "wanted_frame_time");

_LIT8(KEffectMinTimeTag,"min_sleep_time");

_LIT8(KEffectCachePriorityTag, "cachepriority");

_LIT8(KPathTag, "path");

_LIT8(KMaxTransCacheSizeTag, "max_transition_cache_size");

_LIT8(KMaxCacheSizeTag, "max_cache_size");

_LIT8(KFullSCRTransTag,"fullscreentransitions");

_LIT8(KTransitionTag, "transition");

_LIT8(KContextTag, "context");

_LIT8(KUidTag, "Uid");

_LIT8(KCtrlTransTag, "controltransitions");

_LIT8(KContextUidTag, "context_uid");

_LIT8(KActionTag, "action");

_LIT8(KActionStringTag, "actionstring" );

_LIT8( KListTransTag, "listtransitions");

_LIT8( KTypeTag, "type" );

const TInt KListBackgroundContext = 1;

const TInt KListItemContext = 2;

_LIT(KTFXManifestFile, "z:\\resource\\effects\\manifest.mf");

CTFxEffect::~CTFxEffect()

    {

    delete iName;

    delete iFilename;

    }

const TDesC& CTFxEffect::Name()

    {

    if (!iName)

        {

        return KNullDesC;

        }

    return *iName;

    }

const TDesC& CTFxEffect::Filename()

    {

    if (!iFilename)

        {

        return KNullDesC;

        }

    return *iFilename;

    }

    {

    if (iName)

        {

        delete iName;

        iName = NULL;

        }

    iName = HBufC::NewL(aName.Length()*2);

    iName->Des().Copy(aName);

    }

    {

    if (iFilename)

        {

        delete iFilename;

        iFilename = NULL;

        }

    iFilename = HBufC::NewL(aFilename.Length()*2);

    iFilename->Des().Copy(aFilename);

    }

TInt CTFxEffect::WantedTime()

    {

    return iWantedTime;

    }

TInt CTFxEffect::MinTime()

    {

    return iMinTime;

    }

TInt CTFxEffect::CachePriority()

    {

    return iCachePriority;

    }

    {

    if (aTime.Length() > 0)

        {

        TLex8 lexer(aTime);

        User::LeaveIfError(lexer.Val(iWantedTime));

        }

    else

        {

        iWantedTime = -1;

        }

    }

    {

    if (aTime.Length() > 0)

        {

        TLex8 lexer(aTime);

        User::LeaveIfError(lexer.Val(iMinTime));

        }

    else

        {

        iMinTime = -1;

        }

    }

    {

    if (aPriority.Length() > 0)

        {

        TLex8 lexer(aPriority);

        User::LeaveIfError(lexer.Val(iCachePriority));

        }

    else

        {

        iCachePriority = -1;

        }

    }

CTFxEffect::CTFxEffect() :  iWantedTime(-1), iMinTime(-1), iCachePriority(-1), iPathIndex(-1)

    {

    }

TInt CTFxEffect::PathIndex()

    {

    return iPathIndex;

    }

void CTFxEffect::SetPathIndex(TInt aIndex)

    {

    iPathIndex = aIndex;

    }

void CTFxEffect::SetMaxCacheSize(TInt aSize)

    {

    iMaxCacheSize = aSize;

    }

void CTFxEffect::SetMaxTransCacheSize(TInt aSize)

    {

    iMaxTransCacheSize = aSize;

    }

TInt CTFxEffect::MaxCacheSize()

    {

    return iMaxCacheSize;

    }

TInt CTFxEffect::MaxTransCacheSize()

    {

    return iMaxTransCacheSize;

    }

CTFxTransition::CTFxTransition()

    {

    }

CTFxTransition::~CTFxTransition()

    {

    delete iEffectName;

    }

const TUid CTFxTransition::Uid()

    {

    return iUid;

    }

TInt CTFxTransition::Type()

    {

    return iType;

    }

    {

    if (aUid.Length())

        {

        TLex8 lexer(aUid.Mid(2));

        TUint32 uid;

        User::LeaveIfError(lexer.BoundedVal(uid,EHex,KMaxTUint));

        iUid.iUid = uid;

        }

    else

        {

        iUid = KNullUid;

        }

    }

TInt CTFxTransition::ContextId()

    {

    return iContextId;

    }

    {

    if (aId.Length() > 0)

        {

        TLex8 lexer(aId);

        User::LeaveIfError(lexer.Val(iContextId));

        }

    else

        {

        iContextId = KMaxTInt;

        }

    }

void CTFxTransition::SetEffectNameL(const TDesC8& aEffect)

    {

    if (iEffectName)

        {

        delete iEffectName;

        iEffectName = NULL;

        }

    iEffectName = HBufC::NewL(aEffect.Length()*2);

    iEffectName->Des().Copy(aEffect);

    }

    {

    if (aType.Length() > 0)

        {

        TLex8 lexer(aType);

        User::LeaveIfError(lexer.Val(iType));

        }

    else

        {

        iType = 0;

        }

    }

const TDesC& CTFxTransition::EffectName()

    {

    if (iEffectName)

        {

        return *iEffectName;

        }

    return KNullDesC;

    }

void CTFxTransition::SetEffect(CTFxEffect* aEffect)

    {

    iEffect = aEffect;

    }

CTFxEffect* CTFxTransition::Effect()

    {

    return iEffect;

    }

CTFXConfigParser* CTFXConfigParser::NewL()

    {

    CTFXConfigParser* self = new (ELeave) CTFXConfigParser;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

CTFxCtrlTransition::CTFxCtrlTransition()

    {

    }

CTFxCtrlTransition::~CTFxCtrlTransition()

    {

    delete iEffectName;

    delete iActionString;

    }

const TUid CTFxCtrlTransition::ContextUid()

    {

    return iContextUid;

    }

void CTFxCtrlTransition::SetContextUidL(const TDesC8& aUid)

    {

    if (aUid.Length())

        {

        TLex8 lexer(aUid.Mid(2));

        TUint32 uid;

        User::LeaveIfError(lexer.BoundedVal(uid,EHex,KMaxTUint));

        iContextUid.iUid = uid;

        }

    else

        {

        iContextUid = KNullUid;

        }

    }

const TDesC& CTFxCtrlTransition::EffectName()

    {

    if (!iEffectName)

        {

        return KNullDesC;

        }

    return *iEffectName;

    }

void CTFxCtrlTransition::SetEffectNameL(const TDesC8& aEffect)

    {

    if (iEffectName)

        {

        delete iEffectName;

        iEffectName = NULL;

        }

    iEffectName = HBufC::NewL(aEffect.Length()*2);

    iEffectName->Des().Copy(aEffect);

    }

void CTFxCtrlTransition::SetActionStringL(const TDesC8& aActionStr)

    {

    if (iActionString)

        {

        delete iActionString;

        iActionString = NULL;

        }

    iActionString = HBufC::NewL(aActionStr.Length()*2);

    iActionString->Des().Copy(aActionStr);

    }

const TDesC& CTFxCtrlTransition::ActionString()

    {

    if (!iActionString)

        {

        return KNullDesC;

        }

    return *iActionString;

    }

void CTFxCtrlTransition::SetActionL(const TDesC8& aAction)

    {

    if (aAction.Length() > 0)

        {

        TLex8 lexer(aAction);

        User::LeaveIfError(lexer.Val(iAction));

        }

    else

        {

        iAction = 0;

        }

    }

TInt  CTFxCtrlTransition::Action()

    {

    return iAction;

    }

CTFxEffect*  CTFxCtrlTransition::Effect()

    {

    return iEffect;

    }

void CTFxCtrlTransition::SetEffect(CTFxEffect* aEffect)

    {

    iEffect = aEffect;

    }

void CTFxCtrlTransition::SetKmlRegistrationStatus(TBool aStatus)

    {

    iKmlRegistrationStatus = aStatus;

    }

TBool CTFxCtrlTransition::KmlRegistrationStatus()

    {

    return iKmlRegistrationStatus;

    }

void CTFXConfigParser::ConstructL()

    {

    iParser = CParser::NewL(KMimetype(), *this);

    }

CTFXConfigParser::CTFXConfigParser() : iParserState(EStateParsingNone)

    {

    }

CTFXConfigParser::~CTFXConfigParser()

    {

    if (iFsEffectArray)

        {

        iFsEffectArray->ResetAndDestroy();

        }

    if (iFsTransitionArray)

        {

        iFsTransitionArray->ResetAndDestroy();

        }

    if (iEffectDefPathArray)

        {

        iEffectDefPathArray->ResetAndDestroy();

        }

    if (iCtrlTransitionArray)

        {

        iCtrlTransitionArray->ResetAndDestroy();

        }

    if (iListTransitionArray)

        {

        iListTransitionArray->ResetAndDestroy();

        }

    delete iFsEffectArray;

    delete iFsTransitionArray;

    delete iEffectDefPathArray;

    delete iCtrlTransitionArray;

    delete iParser;

    delete iListTransitionArray;

    }

const TDesC& CTFXConfigParser::KmlBasePath(TInt aIndex)

    {

    if (iEffectDefPathArray && iEffectDefPathArray->Count() >= aIndex+1)

        {

        return *(iEffectDefPathArray->operator[](aIndex));

        }

    return KNullDesC;

    }

const TDesC& CTFXConfigParser::BaseSkinSelFile() const

    {

    return iBaseSkinSelFile;

    }

RPointerArray<CTFxTransition>* CTFXConfigParser::FsTransitionArrayL()

    {

    if (iFsTransitionArray)

        {

        return iFsTransitionArray;

        }

    return NULL; // disables compiler nag

    }

RPointerArray<CTFxCtrlTransition>* CTFXConfigParser::CtrlTransitionArrayL()

    {

    if (iCtrlTransitionArray)

        {

        return iCtrlTransitionArray;

        }

    return NULL; // disables compiler nag

    }

RPointerArray<CTFxTransition>* CTFXConfigParser::ListTransitionArrayL()

    {

    if (iListTransitionArray)

        {

        return iListTransitionArray;

        }

    return NULL; // disables compiler nag

    }

void CTFXConfigParser::ParseL(const TDesC& aFilename)

    {

    RFs fs;

    User::LeaveIfError(fs.Connect());

    CleanupClosePushL(fs);

    RFile file;

    User::LeaveIfError(file.Open(fs, aFilename, EFileRead | EFileShareReadersOnly));

    CleanupClosePushL(file);

    TInt filesize = 0;

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

    HBufC8* buffer = HBufC8::NewLC(filesize);

    TPtr8 ptr( buffer->Des() );

    User::LeaveIfError(file.Read(ptr, filesize));

    iParser->ParseBeginL();

    iParser->ParseL(*buffer);

    iParser->ParseEndL();

    CleanupStack::PopAndDestroy(3); // fs, file, buffer

    }

void CTFXConfigParser::OnStartDocumentL(const RDocumentParameters& /*aDocParam*/, TInt /*aErrorCode*/)

    {

    }

void CTFXConfigParser::OnEndDocumentL(TInt /*aErrorCode*/)

    {

    }

void CTFXConfigParser::OnStartElementL(const RTagInfo& aElement, const RAttributeArray& aAttributes, TInt aErrorCode)