diff -r 000000000000 -r 05e9090e2422 skins/AknSkins/srvsrc/tfxconfigparser.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/skins/AknSkins/srvsrc/tfxconfigparser.cpp	Thu Dec 17 09:14:12 2009 +0200
@@ -0,0 +1,1111 @@
+/*
+* 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;
+    }
+
+void CTFxEffect::SetName(const TDesC8& aName)
+    {
+    if (iName)
+        {
+        delete iName;
+        iName = NULL;
+        }
+    iName = HBufC::NewL(aName.Length()*2);
+    iName->Des().Copy(aName);
+    }
+
+void CTFxEffect::SetFilename(const TDesC8& aFilename)
+    {
+    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;
+    }
+
+void CTFxEffect::SetWantedTime(const TDesC8& aTime)
+    {
+    if (aTime.Length() > 0)
+        {
+        TLex8 lexer(aTime);
+        User::LeaveIfError(lexer.Val(iWantedTime));
+        }
+    else
+        {
+        iWantedTime = -1;
+        }
+    }
+
+void CTFxEffect::SetMinTime(const TDesC8& aTime)
+    {
+    if (aTime.Length() > 0)
+        {
+        TLex8 lexer(aTime);
+        User::LeaveIfError(lexer.Val(iMinTime));
+        }
+    else
+        {
+        iMinTime = -1;
+        }
+    }
+
+void CTFxEffect::SetCachePriority(const TDesC8& aPriority)
+    {
+    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;
+    }
+
+void CTFxTransition::SetUid(const TDesC8& aUid)
+    {
+    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;
+    }
+
+
+void CTFxTransition::SetContextId(const TDesC8& aId)
+    {
+    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);
+    }
+
+void CTFxTransition::SetType(const TDesC8& aType)
+    {
+    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)
+    {
+    if (iFileType == EConfigFileManifest)
+        {
+        OnMfStartElementL(aElement, aAttributes, aErrorCode);
+        return;
+        }
+    else if (iFileType == EConfigFileSel)
+        {
+        OnSelStartElementL(aElement, aAttributes, aErrorCode);
+        return;
+        }
+
+
+    if (!aElement.LocalName().DesC().CompareF(KManifestTag))
+        {
+        iFileType = EConfigFileManifest;
+        return;
+        }
+    else if (!aElement.LocalName().DesC().CompareF(KSelTag))
+        {
+        iFileType = EConfigFileSel;
+
+        // find if there's baseskin attribute
+        // if baseskin is found then parsing is stopped and
+        // baseskin is parsed and registered first
+        TInt attrCount( aAttributes.Count() );
+        for( TInt i( 0 ); i < attrCount; i++ )
+            {
+            RAttribute attribute = aAttributes[i];
+            RTagInfo tag = attribute.Attribute();
+            if (!tag.LocalName().DesC().CompareF(KBaseSkinTag))
+                {
+                // base skin can be found once per parser
+                if( iBaseSkinSelFile.Length() == 0 )
+                    {
+                    iBaseSkinSelFile.Copy( attribute.Value().DesC() );
+                    User::Leave( KBaseSkinParserLeave );
+                    }
+                }
+            }
+        return;
+        }
+    }
+
+void CTFXConfigParser::OnEndElementL(const RTagInfo& aElement, TInt aErrorCode)
+    {
+    if (!aElement.LocalName().DesC().CompareF(KManifestTag))
+        {
+        iFileType = EConfigFileUndefined;
+        iManifestParsed = ETrue;
+        return;
+        }
+    else if (!aElement.LocalName().DesC().CompareF(KSelTag))
+        {
+        iFileType = EConfigFileUndefined;
+        return;
+        }
+
+    if (iFileType == EConfigFileManifest)
+        {
+        OnMfEndElementL(aElement, aErrorCode);
+        iExtensionParsed = ETrue;
+        return;
+        }
+    else if (iFileType == EConfigFileSel)
+        {
+        OnSelEndElementL(aElement, aErrorCode);
+        return;
+        }
+    }
+
+void CTFXConfigParser::OnContentL(const TDesC8& /*aBytes*/, TInt /*aErrorCode*/)
+    {
+    }
+
+void CTFXConfigParser::OnStartPrefixMappingL(const RString& /*aPrefix*/, const RString& /*aUri*/, TInt /*aErrorCode*/)
+    {
+    }
+
+void CTFXConfigParser::OnEndPrefixMappingL(const RString& /*aPrefix*/, TInt /*aErrorCode*/)
+    {
+    }
+
+void CTFXConfigParser::OnIgnorableWhiteSpaceL(const TDesC8& /*aBytes*/, TInt /*aErrorCode*/)
+    {
+    }
+
+void CTFXConfigParser::OnSkippedEntityL(const RString& /*aName*/, TInt /*aErrorCode*/)
+    {
+    }
+
+void CTFXConfigParser::OnProcessingInstructionL(const TDesC8& /*aTarget*/, const TDesC8& /*aData*/, TInt /*aErrorCode*/)
+    {
+    }
+
+void CTFXConfigParser::OnError(TInt /*aErrorCode*/)
+    {
+    }
+
+TAny* CTFXConfigParser::GetExtendedInterface(const TInt32 /*aUid*/)
+    {
+    return NULL;
+    }
+
+void CTFXConfigParser::SetMaxTransCacheSizeL(const TDesC8& aCacheSize)
+    {
+    if (aCacheSize.Length() > 0)
+        {
+        TLex8 lexer(aCacheSize);
+        User::LeaveIfError(lexer.Val(iMaxTransCacheSize));
+        }
+    else
+        {
+        iMaxTransCacheSize = 0;
+        }
+    }
+
+void CTFXConfigParser::SetMaxCacheSizeL(const TDesC8& aCacheSize)
+    {
+    if (aCacheSize.Length() > 0)
+        {
+        TLex8 lexer(aCacheSize);
+        User::LeaveIfError(lexer.Val(iMaxCacheSize));
+        }
+    else
+        {
+        iMaxCacheSize = 0;
+        }
+    }
+
+void CTFXConfigParser::OnMfStartElementL(const RTagInfo& aElement, const RAttributeArray& aAttributes, TInt /*aErrorCode*/)
+    {
+    if (!aElement.LocalName().DesC().CompareF(KEffectDefinitionsTag))
+        {
+        if (!iFsEffectArray)
+            {
+            iFsEffectArray = new (ELeave) RPointerArray<CTFxEffect>;
+            }
+        if (!iEffectDefPathArray)
+            {
+            iEffectDefPathArray = new (ELeave) RPointerArray<HBufC>;
+            }
+        for (TInt count = 0; count < aAttributes.Count(); count++)
+            {
+            RAttribute attribute = aAttributes[count];
+            RTagInfo tag = attribute.Attribute();
+            if (!tag.LocalName().DesC().CompareF(KPathTag))
+                {
+                HBufC* path;
+                path = HBufC::NewL(attribute.Value().DesC().Length()*2);
+                path->Des().Copy(attribute.Value().DesC());
+                iEffectDefPathArray->Append(path);
+                }
+            else if (!tag.LocalName().DesC().CompareF(KMaxTransCacheSizeTag))
+                {
+                SetMaxTransCacheSizeL(attribute.Value().DesC());
+                }
+            else if (!tag.LocalName().DesC().CompareF(KMaxCacheSizeTag))
+                {
+                SetMaxCacheSizeL(attribute.Value().DesC());
+                }
+            }
+        return;
+        }
+    else if (!aElement.LocalName().DesC().CompareF(KEffectTag))
+        {
+        if (!iFsEffectArray)
+            {
+            User::Leave(KErrCorrupt);
+            }
+        iCurrentEffect = new (ELeave) CTFxEffect;
+        iCurrentEffect->SetPathIndex(iEffectDefPathArray->Count()-1);
+        iCurrentEffect->SetMaxTransCacheSize(iMaxTransCacheSize);
+        iCurrentEffect->SetMaxCacheSize(iMaxCacheSize);
+        }
+
+    for (TInt count = 0; count < aAttributes.Count(); count++)
+        {
+        RAttribute attribute = aAttributes[count];
+        RTagInfo tag = attribute.Attribute();
+        if (!tag.LocalName().DesC().CompareF(KEffectNameTag))
+            {
+            iCurrentEffect->SetName(attribute.Value().DesC());
+            }
+        else if (!tag.LocalName().DesC().CompareF(KEffectFileTag))
+            {
+            iCurrentEffect->SetFilename(attribute.Value().DesC());
+            }
+        else if (!tag.LocalName().DesC().CompareF(KEffectWantedTimeTag))
+            {
+            iCurrentEffect->SetWantedTime(attribute.Value().DesC());
+            }
+        else if (!tag.LocalName().DesC().CompareF(KEffectMinTimeTag))
+            {
+            iCurrentEffect->SetMinTime(attribute.Value().DesC());
+            }
+        else if (!tag.LocalName().DesC().CompareF(KEffectCachePriorityTag))
+            {
+            iCurrentEffect->SetCachePriority(attribute.Value().DesC());
+            }
+        }
+    }
+
+void CTFXConfigParser::OnSelStartElementL(const RTagInfo& aElement, const RAttributeArray& aAttributes, TInt /*aErrorCode*/)
+    {
+    if (!aElement.LocalName().DesC().CompareF(KFullSCRTransTag))
+        {
+        iFsTransitionArray = new (ELeave) RPointerArray<CTFxTransition>;
+        iParserState = EStateParsingFs;
+        return;
+        }
+    else if (!aElement.LocalName().DesC().CompareF(KCtrlTransTag))
+        {
+        iCtrlTransitionArray = new (ELeave) RPointerArray<CTFxCtrlTransition>;
+        iParserState = EStateParsingCtrl;
+        return;
+        }
+    else if(!aElement.LocalName().DesC().CompareF(KListTransTag))
+        {
+        iListTransitionArray = new (ELeave) RPointerArray<CTFxTransition>;
+        iParserState = EStateParsingList;
+        }
+
+   else if (!aElement.LocalName().DesC().CompareF(KTransitionTag))
+        {
+        if (iParserState == EStateParsingFs && !iFsTransitionArray)
+            {
+            User::Leave(KErrCorrupt);
+            }
+        else if (iParserState == EStateParsingCtrl && !iCtrlTransitionArray)
+            {
+            User::Leave(KErrCorrupt);
+            }
+        else if (iParserState == EStateParsingList && !iListTransitionArray)
+            {
+            User::Leave(KErrCorrupt);
+            }
+        // list transition has same params as fs transition
+        if (iParserState == EStateParsingFs
+            || iParserState == EStateParsingList)
+            {
+            iCurrentTransition = new (ELeave) CTFxTransition;
+
+            for (TInt count = 0; count < aAttributes.Count(); count++)
+                {
+                RAttribute attribute = aAttributes[count];
+                RTagInfo tag = attribute.Attribute();
+                if (!tag.LocalName().DesC().CompareF(KContextTag))
+                    {
+                    iCurrentTransition->SetContextId(attribute.Value().DesC());
+                    }
+                else if (!tag.LocalName().DesC().CompareF(KEffectTag))
+                    {
+                    iCurrentTransition->SetEffectNameL(attribute.Value().DesC());
+                    }
+                else if (!tag.LocalName().DesC().CompareF(KUidTag))
+                    {
+                    iCurrentTransition->SetUid(attribute.Value().DesC());
+                    }
+                else if( !tag.LocalName().DesC().CompareF(KTypeTag))
+                    {
+                    iCurrentTransition->SetType(attribute.Value().DesC());
+                    }
+                }
+            }
+        else if (iParserState == EStateParsingCtrl)
+            {
+            iCurrentCtrlTransition = new (ELeave) CTFxCtrlTransition;
+            for (TInt count = 0; count < aAttributes.Count(); count++)
+                {
+                RAttribute attribute = aAttributes[count];
+                RTagInfo tag = attribute.Attribute();
+                if (!tag.LocalName().DesC().CompareF(KContextUidTag))
+                    {
+                    iCurrentCtrlTransition->SetContextUidL(attribute.Value().DesC());
+                    }
+                else if (!tag.LocalName().DesC().CompareF(KEffectTag))
+                    {
+                    iCurrentCtrlTransition->SetEffectNameL(attribute.Value().DesC());
+                    }
+                else if (!tag.LocalName().DesC().CompareF(KActionTag))
+                    {
+                    iCurrentCtrlTransition->SetActionL(attribute.Value().DesC());
+                    }
+                else if (!tag.LocalName().DesC().CompareF(KActionStringTag))
+                    {
+                    iCurrentCtrlTransition->SetActionStringL(attribute.Value().DesC());
+                    }
+                }
+            }
+        }
+    }
+
+void CTFXConfigParser::OnMfEndElementL(const RTagInfo& aElement, TInt /*aErrorCode*/)
+    {
+    if (!aElement.LocalName().DesC().CompareF(KEffectDefinitionsTag))
+        {
+        }
+    else if (!aElement.LocalName().DesC().CompareF(KEffectTag))
+        {
+        iFsEffectArray->Append(iCurrentEffect);
+        iCurrentEffect = NULL;
+        }
+    }
+
+void CTFXConfigParser::OnSelEndElementL(const RTagInfo& aElement, TInt /*aErrorCode*/)
+    {
+    if (!aElement.LocalName().DesC().CompareF(KFullSCRTransTag))
+        {
+        iParserState = EStateParsingNone;
+        return;
+        }
+    else if (!aElement.LocalName().DesC().CompareF(KCtrlTransTag))
+        {
+        iParserState = EStateParsingNone;
+        return;
+        }
+    else if(!aElement.LocalName().DesC().CompareF(KListTransTag))
+        {
+        iParserState = EStateParsingNone;
+        return;
+        }
+
+    if (iParserState == EStateParsingFs || iParserState == EStateParsingList )
+        {
+        if (!aElement.LocalName().DesC().CompareF(KTransitionTag))
+            {
+            if (iFsEffectArray)
+                {
+                // pick up the associated kml file to the transition
+                // from the effect definition
+                for (TInt count = 0; count < iFsEffectArray->Count(); count++)
+                    {
+                    CTFxEffect* effect = iFsEffectArray->operator[](count);
+                    if (! ( effect->Name().CompareF(iCurrentTransition->EffectName()) ) )
+                        {
+                        if (iCurrentTransition->ContextId() != KMaxTInt)
+                            {
+                            iCurrentTransition->SetEffect(effect);
+                            }
+                        }
+                    }
+                }
+            if( iParserState == EStateParsingFs )
+                {
+                iFsTransitionArray->Append(iCurrentTransition);
+                }
+            else
+                {
+                iListTransitionArray->Append(iCurrentTransition);
+                }
+            iCurrentTransition=NULL;
+            }
+        }
+    else if (iParserState == EStateParsingCtrl)
+        {
+        if (!aElement.LocalName().DesC().CompareF(KTransitionTag))
+            {
+            if (iFsEffectArray)
+                {
+                // pick up the associated kml file to the transition
+                // from the effect definition
+                TInt count = 0;
+                for (count = 0; count < iFsEffectArray->Count(); count++)
+                    {
+                    CTFxEffect* effect = iFsEffectArray->operator[](count);
+                    if (! ( effect->Name().CompareF(iCurrentCtrlTransition->EffectName()) ) )
+                        {
+                        iCurrentCtrlTransition->SetEffect(effect);
+                        }
+                    }
+                // find duplicate kmls so that kml files get registered only once
+                for (count = 0; count < iCtrlTransitionArray->Count(); count++)
+                    {
+                    CTFxCtrlTransition* trans = iCtrlTransitionArray->operator[](count);
+                    if (!trans->EffectName().CompareF(iCurrentCtrlTransition->EffectName()))
+                        {
+                        iCurrentCtrlTransition->SetKmlRegistrationStatus(ETrue);
+                        break;
+                        }
+                    }
+                }
+            iCtrlTransitionArray->Append(iCurrentCtrlTransition);
+            iCurrentCtrlTransition=NULL;
+            }
+        }
+    }
+
+void StartSrvAndRegisterTransitionsL(const TDesC& aSkinExtensionFilename,
+                                    MTransitionServer* aTransSrv,
+                                    MTransitionServerController* aTransSrvCtrl,
+                                    CTFXConfigParser* aConfigParser,
+                                    TBool aSkipSrvStart )
+    {
+
+    aConfigParser->ParseL(KTFXManifestFile);
+
+    aConfigParser->ParseL(aSkinExtensionFilename);
+
+    // effectarray is owned by the parser -> don't push it
+    RPointerArray<CTFxTransition>* transitionarray = aConfigParser->FsTransitionArrayL();
+
+    RPointerArray<CTFxCtrlTransition>* ctrltransitionarray = aConfigParser->CtrlTransitionArrayL();
+
+    RPointerArray<CTFxTransition>* listTransitionArray = aConfigParser->ListTransitionArrayL();
+
+    TInt err(KErrNone);
+
+    if (!transitionarray && !ctrltransitionarray && !listTransitionArray )
+        {
+        User::Leave(KErrGeneral);
+        }
+
+    TInt maxtransitioncachesize = 0;
+    TInt maxcachesize = 0;
+    if (transitionarray && transitionarray->Count())
+        {
+        CTFxTransition* transition = transitionarray->operator[](0);
+        CTFxEffect* effect = transition->Effect();
+        if (effect)
+            {
+            maxtransitioncachesize = effect->MaxTransCacheSize();
+            maxcachesize = effect->MaxCacheSize();
+            }
+        }
+    else if (ctrltransitionarray && ctrltransitionarray->Count())
+        {
+        CTFxCtrlTransition* ctrltransition = ctrltransitionarray->operator[](0);
+        CTFxEffect* effect = ctrltransition->Effect();
+        if (effect)
+            {
+            maxtransitioncachesize = effect->MaxTransCacheSize();
+            maxcachesize = effect->MaxCacheSize();
+            }
+        }
+    else if( listTransitionArray && listTransitionArray->Count() )
+        {
+        CTFxTransition* listTransition = listTransitionArray->operator[](0);
+        CTFxEffect* effect = listTransition->Effect();
+        if ( effect )
+            {
+            maxtransitioncachesize = effect->MaxTransCacheSize();
+            maxcachesize = effect->MaxCacheSize();
+            }
+        }
+
+    if( !aSkipSrvStart )
+        {
+        User::LeaveIfError(aTransSrvCtrl->StartTransitionServer(
+                                    maxtransitioncachesize, maxcachesize ) );
+        }
+
+    if (!aTransSrv->IsConnected())
+        {
+        User::LeaveIfError(aTransSrv->Connect());
+        }
+
+
+    if (transitionarray)
+        {
+
+        for (TInt count = 0; count < transitionarray->Count();count++)
+            {
+            CTFxTransition* transition = transitionarray->operator[](count);
+            CTFxEffect* effect = transition->Effect();
+            if (transition && effect && effect->PathIndex() >=0)
+                {
+                err = aTransSrv->RegisterFullscreenKml(transition->ContextId(),
+                    transition->Uid(),
+                    aConfigParser->KmlBasePath(effect->PathIndex()),
+                    effect->Filename(),
+                    effect->CachePriority(),
+                    effect->WantedTime(),
+                    effect->MinTime());
+                }
+            // in KML registration leave only in OOM cases, otherwise
+            // ignore errors and try to register all possible KMLs
+            if( err == KErrNoMemory )
+                {
+                User::LeaveNoMemory();
+                }
+            }
+        }
+    if (ctrltransitionarray)
+        {
+
+        for (TInt count = 0; count < ctrltransitionarray->Count();count++)
+            {
+            CTFxCtrlTransition* ctrltransition = ctrltransitionarray->operator[](count);
+            CTFxEffect* effect = ctrltransition->Effect();
+            if (ctrltransition && effect && effect->PathIndex() >=0)
+                {
+                if (!ctrltransition->KmlRegistrationStatus())
+                    {
+                    err = aTransSrv->RegisterControlKml(ctrltransition->ContextUid(),
+                        aConfigParser->KmlBasePath(effect->PathIndex()),
+                        effect->Filename(), effect->WantedTime(), effect->MinTime());
+                    if( err == KErrNoMemory )
+                        {
+                        User::LeaveNoMemory();
+                        }
+                    }
+                err = aTransSrv->RegisterControlAction(ctrltransition->ContextUid(),
+                    ctrltransition->Action(),
+                    ctrltransition->ActionString());
+
+                if( err == KErrNoMemory )
+                    {
+                    User::LeaveNoMemory();
+                    }
+                }
+            }
+        }
+
+    if (listTransitionArray)
+        {
+
+        for( TInt i( 0 ); i < listTransitionArray->Count(); i++ )
+            {
+
+            CTFxTransition* listTransition = listTransitionArray->operator[](i);
+
+            CTFxTransition* listBackgroundTrans = NULL;
+            CTFxTransition* listItemTrans = NULL;
+
+            if( listTransition->ContextId() == KListBackgroundContext )
+                {
+                listBackgroundTrans = listTransition;
+                }
+            else if( listTransition->ContextId() == KListItemContext )
+                {
+                listItemTrans = listTransition;
+                }
+
+            // find a pair (list item - list background) for this transition
+            for( TInt j(i+1); j < listTransitionArray->Count(); j++ )
+                {
+                CTFxTransition* lt = listTransitionArray->operator[]( j );
+
+                if ( (lt->Uid() == listTransition->Uid()) &&
+                    lt->Type() == listTransition->Type() )
+                    {
+                    if( lt->ContextId() == KListBackgroundContext )
+                        {
+                        listBackgroundTrans = lt;
+                        }
+                     else if( lt->ContextId() == KListItemContext )
+                        {
+                        listItemTrans = lt;
+                        }
+                    }
+                }
+
+            if( listBackgroundTrans && listItemTrans )
+                {
+                CTFxEffect* listBgEffect = listBackgroundTrans->Effect();
+                CTFxEffect* listItemEffect = listItemTrans->Effect();
+
+                if( listBgEffect && listItemEffect )
+                    {
+                    TInt type( 0 );
+                    type = listBackgroundTrans->Type();
+                    if( type == 0 )
+                        {
+                        type = listItemTrans->Type();
+                        }
+
+                    err = aTransSrv->RegisterListBoxKml(
+                                            listBackgroundTrans->Uid(),
+                                            type,
+                                            aConfigParser->KmlBasePath(listBgEffect->PathIndex()),
+                                            listBgEffect->Filename(),
+                                            listItemEffect->Filename() );
+
+                    if( err == KErrNoMemory )
+                        {
+                        User::LeaveNoMemory();
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+// End of file