diff -r 000000000000 -r 05e9090e2422 layouts/cdl/CdlEngine/src/CdlEngine.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/layouts/cdl/CdlEngine/src/CdlEngine.cpp	Thu Dec 17 09:14:12 2009 +0200
@@ -0,0 +1,290 @@
+/*
+* Copyright (c) 2009 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 <e32base.h>
+#include "CdlEngine.h"
+#include "CdlServEng.h"
+#include "CCdlEngine.h"
+#include <e32uid.h>
+#include <f32file.h>
+
+
+void Panic(TCdlEngPanic aReason)
+	{
+	_LIT(KCat, "CdlEng");
+	User::Panic(KCat, aReason);
+	}
+
+
+//
+// CCdlEngineRef
+//
+
+EXPORT_C CCdlEngineRef::~CCdlEngineRef()
+	{
+	__ASSERT_DEBUG(iRefCount==0 || iRefCount==1, Panic(ECdlEngPanic_BadRefCount));
+	ReleaseRef();
+	}
+
+CCdlEngineRef::CCdlEngineRef(CCdlEngineBase* aEngine)
+: iEngine(aEngine)
+	{
+	AddRef();
+	}
+
+void CCdlEngineRef::AddRef()
+	{
+	iEngine->IncRefCount();
+	iRefCount++;
+	}
+
+void CCdlEngineRef::ReleaseRef()
+	{
+	if (iRefCount > 0)
+		{
+		iEngine->DecRefCount();
+		iRefCount--;
+		}
+	}
+
+CCdlEngineBase* CCdlEngineRef::Engine() const
+	{
+	return iEngine;
+	}
+
+
+//
+// CdlEngine
+//
+
+EXPORT_C TBool CdlEngine::IsCdlEngineCreated()
+	{
+	return CCdlEngine::Static() != NULL;
+	}
+
+EXPORT_C CCdlEngineRef* CdlEngine::CreateCdlEngineL()
+	{
+	TBool pushed;
+	CCdlEngine* eng = CCdlEngine::InstanceLC(pushed);
+	CCdlEngineRef* ref = new(ELeave) CCdlEngineRef(eng);
+	if (pushed)
+		CleanupStack::Pop();
+	return ref;
+	}
+
+EXPORT_C TAny* CdlEngine::GetData(TUid aCdlUid, TInt aApiId)
+	{
+	return CCdlEngine::Instance().GetData(aCdlUid, aApiId);
+	}
+
+EXPORT_C TCdlEngineFunc* CdlEngine::GetFunction(TUid aCdlUid, TInt aApiId)
+	{
+	CCdlEngine& eng = CCdlEngine::Instance();
+	CCdlCustomisationStack** pCust = eng.iCustomisations.Find(aCdlUid.iUid);
+	if(!pCust)
+		{
+		Panic(ECdlEngPanic_CustomisationNotPresent);
+		return NULL;
+		}
+	
+		CCdlCustomisationStack* stack = *pCust;
+			const CCdlInstance* inst = stack->iTop;
+			__ASSERT_ALWAYS(inst, Panic(ECdlEngPanic_NoInstanceLoaded));
+			inst->iLastApi = aApiId;
+			eng.SetLastApiId(aApiId);
+			TCdlEngineFunc* func = 0;
+			do
+				{
+				if (aApiId < inst->Interface().iApiSize)
+					func = (TCdlEngineFunc*)(inst->Implementation(aApiId));
+				inst = inst->iSubLayer;
+				} while (!func && inst);
+			__ASSERT_ALWAYS(func, Panic(ECdlEngPanic_NoImplementation));
+			return func;
+	}
+
+
+//
+// Note that if this method is called, then GetFunction will naturally be called on the resulting instance
+// and not on CdlEngine, which means that the stack iteration will not be repeated unnecessarily
+// 
+EXPORT_C const CCdlInstance* CdlEngine::Implementor(TUid aCdlUid, TInt aApiId)
+	{
+	CCdlEngine& eng = CCdlEngine::Instance();
+	CCdlCustomisationStack** pCust = eng.iCustomisations.Find(aCdlUid.iUid);
+	if(!pCust)
+		{
+		Panic(ECdlEngPanic_CustomisationNotPresent);
+		}
+		CCdlCustomisationStack* stack = *pCust;
+			const CCdlInstance* inst = stack->iTop;
+			__ASSERT_ALWAYS(inst, Panic(ECdlEngPanic_NoInstanceLoaded));
+			return inst->Implementor(aApiId);
+	}
+	
+	
+EXPORT_C void CdlEngine::RequireCustomisationL(const SCdlInterface* aInterfaceParams)
+	{
+	CCdlEngine::Instance().RequireCustomisationL(aInterfaceParams);
+	}
+
+EXPORT_C void CdlEngine::LoadCustomisationL(const TCdlRef& aRef)
+	{
+	CCdlEngine::Instance().LoadCustomisationL(aRef);
+	}
+
+EXPORT_C TBool CdlEngine::IsCustomisationStarted(const SCdlInterface* aInterfaceParams)
+	{
+	return CCdlEngine::Instance().IsCustomisationStarted(aInterfaceParams);
+	}
+
+EXPORT_C const CCdlInstance& CdlEngine::CustomisationInstance(TUid aCdlUid)
+	{
+	return CCdlEngine::Instance().CustomisationInstance(aCdlUid);
+	}
+
+EXPORT_C const TCdlRef& CdlEngine::LastAccessedRef(TUid aCdlUid)
+	{
+	return CCdlEngine::Instance().LastAccessedRef(aCdlUid);
+	}
+
+EXPORT_C void CdlEngine::FileNameRelativeToLastAccessedInstance(TUid aCdlUid, TFileName& aFileName)
+	{
+	CCdlEngine::Instance().FileNameRelativeToLastAccessedInstance(aCdlUid, aFileName);
+	}
+
+EXPORT_C TInt CdlEngine::LastApiId()
+	{
+	return CCdlEngine::Instance().LastApiId();
+	}
+
+EXPORT_C CCdlRefs* CdlEngine::FindInstancesLC(TUid aCdlUid)
+	{
+	return CCdlEngine::Instance().FindInstancesLC(aCdlUid);
+	}
+
+EXPORT_C CCdlRefCollection* CdlEngine::FileContentsLC(const TDesC& aFileName)
+	{
+	return CCdlEngine::Instance().FileContentsLC(aFileName);
+	}
+
+EXPORT_C CCdlNames* CdlEngine::FindCustomisationFilesLC()
+	{
+	return CCdlEngine::Instance().FindCustomisationFilesLC();
+	}
+
+EXPORT_C CCdlRefs* CdlEngine::AllAvailableRefsLC()
+	{
+	return CCdlEngine::Instance().AllAvailableRefsLC();
+	}
+
+EXPORT_C void CdlEngine::SetLocalStateL(const CCdlRefs& aState)
+	{
+	CCdlEngine::Instance().SetLocalStateL(aState);
+	}
+
+EXPORT_C void CdlEngine::SetGlobalStateL(const CCdlRefs& aState)
+	{
+	CCdlEngine::Instance().SetGlobalStateL(aState);
+	}
+
+EXPORT_C CCdlRefs* CdlEngine::LocalStateLC(const CCdlUids& aCdlUids)
+	{
+	return CCdlEngine::Instance().LocalStateLC(aCdlUids);
+	}
+
+EXPORT_C CCdlRefs* CdlEngine::GlobalStateLC(const CCdlUids& aCdlUids)
+	{
+	return CCdlEngine::Instance().GlobalStateLC(aCdlUids);
+	}
+
+EXPORT_C void CdlEngine::EnableGlobalCustomisationL(const CCdlUids& aCdlUids, TBool aEnabled)
+	{
+	CCdlEngine::Instance().EnableGlobalCustomisationL(aCdlUids, aEnabled);
+	}
+
+EXPORT_C void CdlEngine::StartGlobalCustomisationL()
+	{
+	CCdlEngine::Instance().StartGlobalCustomisationL();
+	}
+
+EXPORT_C void CdlEngine::SetCustomisationChangeObserverL(MCdlChangeObserver* aObserver, TUid aUid)
+	{
+	CCdlEngine::Instance().AddCustomisationChangeObserverL(aObserver, aUid);
+	}
+
+EXPORT_C void CdlEngine::SetAvailableRefsChangeObserverL(MCdlChangeObserver* aObserver)
+	{
+	CCdlEngine::Instance().AddGeneralChangeObserverL(aObserver);
+	}
+
+EXPORT_C TInt CdlEngine::CompareNames(const TDesC& aLeft, const TDesC& aRight)
+	{
+	TPtrC left(RCdlLibrary::ExtractName(aLeft));
+	TPtrC right(RCdlLibrary::ExtractName(aRight));
+	// Call Compare first, because it's much faster if the
+	// strings match
+	if (left.Compare(right) == 0)
+		{
+		return 0;
+		}
+	return left.CompareF(right);
+	}
+
+
+//
+// CdlServerEngine
+//
+
+EXPORT_C CCdlEngineRef* CdlServerEngine::CreateCdlEngineL()
+	{
+	TBool pushed;
+	CCdlEngineBase* eng = CCdlEngineBase::InstanceLC(pushed);
+	CCdlEngineRef* ref = new(ELeave) CCdlEngineRef(static_cast<CCdlEngine*>(eng));
+	if (pushed)
+		CleanupStack::Pop();
+	return ref;
+	}
+
+
+//
+// MCdlChangeObserver
+//
+
+EXPORT_C MCdlChangeObserver::~MCdlChangeObserver()
+	{
+	// It's unusual for a M-class to have a real implementation of this function.
+	// This function ensures that an observer will automatically deregister from the
+	// engine on destruction.
+	CCdlEngine* eng = CCdlEngine::Static();
+	if (eng)
+		eng->RemoveChangeObserver(this);
+	}
+
+EXPORT_C void MCdlChangeObserver::HandleCustomisationChangeL(const CCdlUids& /*aUids*/)
+	{
+	}
+
+EXPORT_C void MCdlChangeObserver::HandleAvailableRefsChangeL()
+	{
+	}
+
+#ifndef EKA2
+GLDEF_C TInt E32Dll(TDllReason /*aReason*/)
+	{
+	return(KErrNone);
+	}
+#endif