// Copyright (c) 2006-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 "GfxTransImpl.h"

#include "GfxTransUtils.h"

#include "TransitionControl.h"

#include "RegisteredControl.h"

#include "GfxTransEffectPanic.h"

#include <coecntrl.h>

//

//

const TUid CGfxTransEffect::KTransEffectUid = {0x102822A6};

//

// Construction/Destruction

//

CGfxTransEffect::CGfxTransEffect() :

	CCoeStatic(KTransEffectUid,-1,CCoeStatic::EApp),

	iEnabled(ETrue)

	{

	iCreateHandle = 0;

	}

CGfxTransEffect::~CGfxTransEffect()

	{

	delete iPolicyHandler;

	iInTransition.ResetAndDestroy();

	iInTransition.Close();

	iRegistered.ResetAndDestroy();

	iRegistered.Close();

	iActiveStack.ResetAndDestroy();

	iActiveStack.Close();

	MGfxTransAdapter::Destroy(iAdapter);

	}

TInt CGfxTransEffect::Construct()

	{

	TRAPD(err,iAdapter = MGfxTransAdapter::CreateL(this));

	if(err != KErrNone) 

		{

		return err;

		}

	iPolicyHandler = new CPolicyHandler();

	if(!iPolicyHandler)

		{

		return KErrNoMemory;

		}

	// Get policies from engine

	TInt count;

	TControlPolicy *policies = iAdapter->GetTransitionPolicies(count);

	if(count > 0 && policies != NULL)

		{

		// the policyhandler handles the memory cleanup

		iPolicyHandler->SetTransitionPolicies(policies, count);

		}

	return KErrNone;

	}

CGfxTransEffect* CGfxTransEffect::Static(const CCoeControl * aControl)

	{

	CGfxTransEffect *singleton = StaticNoCreate(aControl);

	if(!singleton)

		{

		singleton = new CGfxTransEffect;

		if(NULL == singleton)

			{

			return NULL;

			}

		if(KErrNone != singleton->Construct())

			{

			delete singleton;

			singleton=NULL;

			return NULL;

			}

		__ASSERT_ALWAYS(aControl->ControlEnv()->FindStatic(KTransEffectUid) == singleton,Panic(EGfxTransEffectFindStatic));

		}

	__ASSERT_ALWAYS(singleton,Panic(EGfxTransEffectNotSingleton));

	return singleton;

	}

CGfxTransEffect* CGfxTransEffect::StaticNoCreate(const CCoeControl * aControl)

	{

	__ASSERT_DEBUG(aControl,Panic(KErrArgument));

	if (!aControl->ControlEnv())

		{

		return NULL;

		}

	return reinterpret_cast<CGfxTransEffect*>(aControl->ControlEnv()->FindStatic(KTransEffectUid));

	}

CGfxTransEffect* CGfxTransEffect::Static()

	{

	if (!CCoeEnv::Static())

		{

		return NULL;

		}

	CGfxTransEffect *singleton = reinterpret_cast<CGfxTransEffect*>(CCoeEnv::Static(KTransEffectUid));

	if(!singleton)

		{

		singleton = new CGfxTransEffect;

		if(NULL == singleton)

			{

			return NULL;

			}

		if(KErrNone != singleton->Construct())

			{

			delete singleton;

			singleton=NULL;

			return NULL;

			}

		__ASSERT_ALWAYS(CCoeEnv::Static(KTransEffectUid) == singleton,Panic(EGfxTransEffectNotSingleton));

		}

	__ASSERT_ALWAYS(singleton,Panic(EGfxTransEffectNotSingleton));

	return singleton;

	}

CGfxTransEffect* CGfxTransEffect::StaticNoCreate()

	{

	if (!CCoeEnv::Static())

		{

		return NULL;

		}

	return reinterpret_cast<CGfxTransEffect*>(CCoeEnv::Static(KTransEffectUid));

	}

//

// API implementation

//

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

// registration

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

void CGfxTransEffect::Register(const CCoeControl * aKey,const TVwsViewId &aView,TUid aType)

	{

	const TInt idx = FindRegistration(aKey);

	if(IsValidIndex(idx)) // previously registered! update. 

		{

		iRegistered[idx]->SetUid(aType);

		iRegistered[idx]->SetViewId(aView);

		iRegistered[idx]->SetType(CRegisteredControl::EView);

		iRegistered[idx]->SetRegistered(ETrue);

		}

	else 

		{

		if(CRegisteredControl* regctrl = new CRegisteredControl(aKey,aView,aType))

			{

			if(KErrNone != iRegistered.Append(regctrl)) 

				{

				//Failed to add, probably due to memory constraints. Fail silently without registering.

				delete regctrl;

				}

			}

		}		

	}

void CGfxTransEffect::Register(const CCoeControl * aKey,TUid aType,TBool aNLayered)

	{

	const TInt idx = FindRegistration(aKey);

	if(IsValidIndex(idx)) // previously registered! update. 

		{

		iRegistered[idx]->SetUid(aType);

		iRegistered[idx]->SetNLayered(aNLayered);

		iRegistered[idx]->SetType(CRegisteredControl::ECoeControl);

		iRegistered[idx]->SetRegistered(ETrue);

		}

	else 

		{

		if(CRegisteredControl* regctrl = new CRegisteredControl(aKey,aType,aNLayered))

			{

			if(KErrNone != iRegistered.Append(regctrl)) 

				{

				//Failed to add, probably due to memory constraints. Fail silently without registering.

				delete regctrl;

				}

			}

		}		

	}

TBool CGfxTransEffect::IsRegistered(const CCoeControl * aKey)

	{

	const TInt idx = FindRegistration(aKey);

	return (IsValidIndex(idx) && iRegistered[idx]->Registered());

	}

void CGfxTransEffect::Deregister(const CCoeControl * aKey)

	{

	const TInt idx = FindRegistration(aKey);

	if(IsValidIndex(idx))

		{

		CRegisteredControl* regctrl = iRegistered[idx];

		TInt activeidx  = iActiveStack.Find(regctrl);

		if(IsValidIndex(activeidx))

			{

			//deregisters between begin and end aborts transition.

			Abort(aKey);

			}

		if(regctrl->InTransitionCount() > 0)

			{

			//If in transition, set registered flag to EFalse

			regctrl->SetRegistered(EFalse);

			//and reset all transition data (such as remotegc)

			regctrl->ResetTransitions();

			//and draw now

			regctrl->Control()->DrawNow();

			}

		else 

			{

			//no ongoing transitions - so remove

			iRegistered.Remove(idx);

			#ifdef _DEBUG

			iRegistered.Compress(); //for __UHEAP_MARK tests.

			#endif

			delete regctrl;

			}

		}

	}

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

// Begin/End   

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

void CGfxTransEffect::Begin(const CCoeControl * aKey,TUint aAction)

	{

	const TInt regidx = FindRegistration(aKey);

	if(!IsValidIndex(regidx) || !(iRegistered[regidx]->Registered()))

		{

		return; //Unregistered controls are silently ignored.

		}

	CRegisteredControl* regctrl = iRegistered[regidx];

	//get policy

	TPolicy policy;

	if(!IsEnabled() || !iAdapter->IsActive())

		{

		policy = ENotSupported;

		}

	else

		{

		policy = iPolicyHandler->GetPolicy(regctrl->Uid(), aAction);

		}

	//reset active and ongoing transitions for this registered control

	if(policy == ESupported)

		{

		regctrl->ResetTransitions();

		}

	//Create a new transition control

	CTransitionControl *transctrl;

	if(NULL == (transctrl = CTransitionControl::New(regctrl, this, aAction, policy, CreateTransitionHandle())))

		{

		return; 

		}

	//add transition to the registered control

	if(KErrNone != regctrl->AddTransition(transctrl))

		{

		delete transctrl;

		return;

		}

	//add to stack

	if(KErrNone != iActiveStack.Push(transctrl))

		{

		delete transctrl;

		return;

		}

	// if supported: Capture Begin state

	iAdapter->HandleClientState(MGfxTransAdapter::EPreBeginCapture, aKey, transctrl->Handle());

	transctrl->CaptureBegin();

	iAdapter->HandleClientState(MGfxTransAdapter::EPostBeginCapture, aKey, transctrl->Handle());

	}

void CGfxTransEffect::BeginLC(const CCoeControl * aKey,TUint aAction)

	{

	const TInt regidx = FindRegistration(aKey);

	if(!IsValidIndex(regidx) || !(iRegistered[regidx]->Registered())) 

		{

		return; //Unregistered controls are silently ignored.

		}

	CRegisteredControl* regctrl = iRegistered[regidx];

	TPolicy policy;

	if(!IsEnabled() || !iAdapter->IsActive())

		{

		policy = ENotSupported;

		}

	else

		{

		policy = iPolicyHandler->GetPolicy(regctrl->Uid(), aAction);

		}

	//reset active and ongoing transitions for this registered control

	if(policy == ESupported)

		{

		regctrl->ResetTransitions();

		}

	//Create a new transition control

	CTransitionControl *transctrl = NULL;

	if(NULL == (transctrl = CTransitionControl::New(regctrl, this, aAction, policy, CreateTransitionHandle())))

		{

		return; 

		}

	//add transition to the registered control

	if(KErrNone != regctrl->AddTransition(transctrl))

		{

		delete transctrl;

		return;

		}

	//add to stack

	if(KErrNone != iActiveStack.PushLC(transctrl))

		{

		delete transctrl;

		return;

		}

	iAdapter->HandleClientState(MGfxTransAdapter::EPreBeginCapture, aKey, transctrl->Handle());

	//capture begin

	transctrl->CaptureBegin();

	iAdapter->HandleClientState(MGfxTransAdapter::EPostBeginCapture, aKey, transctrl->Handle());

	}

void CGfxTransEffect::End(const CCoeControl * aKey)

	{

	CTransitionControl* transctrl = NULL;

	TInt idx = iActiveStack.Find(aKey);

	//Fallback if the control isn't in the iActiveStack

	if(!IsValidIndex(idx))

		{

		Fallback(aKey);

		return;

		}

	iActiveStack.ClearAbove(idx);

	transctrl = iActiveStack.Top();

	if(!transctrl) 

		{

		Fallback(aKey); 

		return;

		}

	iAdapter->HandleClientState(MGfxTransAdapter::EPreEndCapture, transctrl->RegControl()->Control(), transctrl->Handle());

	//capture end	

	transctrl->CaptureEnd();

	iAdapter->HandleClientState(MGfxTransAdapter::EPostEndCapture, transctrl->RegControl()->Control(), transctrl->Handle());

	//pop control from stack 

	iActiveStack.Pop();

	if(!transctrl->Failed())

		{

		// start the transition

		if(	(transctrl->Policy() == ESupported))

			{

			//add control to InTranstionList

			if(KErrNone != iInTransition.Append(transctrl))

				{

				delete transctrl;

				Fallback(aKey);

				return;

				}

			iAdapter->StartTransition(transctrl->Handle());

			if((0 < iInTransition.Count()) && (transctrl == iInTransition[iInTransition.Count() - 1]))

			    {

			    transctrl->SetListenForUpdates(ETrue);

			    }

			}

		// if not supported: draw the updated parts of the control

		else 

			{

			RRegion region;

			if(KErrNone != transctrl->GetUpdatedRegion(region))

				{

				delete transctrl;

				Fallback(aKey);

				return;

				}

			TInt count = region.Count();

			for(TInt i = 0; i < count; i++)

				{

				aKey->DrawNow(region[i]);

				}

			region.Close();

			delete transctrl;

			}

		}

	else 

		{

		delete transctrl;

		Fallback(aKey);

		return;

		}		

	}

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

// NotifyExternalState

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

void CGfxTransEffect::NotifyExternalState(TInt aState, const TDesC8* aArg)

	{

	iAdapter->NotifyExternalState(aState,aArg);	

	}

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

// Abort

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

void CGfxTransEffect::Abort(const CCoeControl * aKey)

	{

	//abort current begin-end pair

	CTransitionControl *current = iActiveStack.Top();

	if(current && current->RegControl()->Control() == aKey)

		{

		iActiveStack.Pop();

		iAdapter->HandleClientState(MGfxTransAdapter::EAbort, aKey, current->Handle());

		delete current;

		}

	}

// global abort

void CGfxTransEffect::Abort()

	{

	CTransitionControl *current = iActiveStack.Top();

	// inform the engine

	if(current)

		{

		iAdapter->HandleClientState(MGfxTransAdapter::EGlobalAbort, current->RegControl()->Control(), 0);

		}

	// delete all transitions in active stack

	while(current)

		{

		iActiveStack.Pop();

		iAdapter->HandleClientState(MGfxTransAdapter::EAbort, current->RegControl()->Control(), current->Handle());

		delete current;

		current = iActiveStack.Top();

		}

	// abort all transitions in InTransition list

	TInt const count = iInTransition.Count();

	for(TInt i = 0; i < count; i++)

		{

		iAdapter->HandleClientState(MGfxTransAdapter::EAbort, iInTransition[i]->RegControl()->Control(), iInTransition[i]->Handle());

		//no removal, wait for TransitionFinished from the server

		}		

	}

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

// Hints

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

void CGfxTransEffect::SetHints(const CCoeControl * aControl,TUint aFlags)

	{

	//first check the active stack for registered controls

	TInt idx = iActiveStack.Find(aControl);	

	if(IsValidIndex(idx))

		{

		iActiveStack[idx]->SetHints(aControl, aFlags);

		return;

		}

	// if not a registered control is active stack

	// check if it is a registered control	

	idx = FindRegistration(aControl);

	if(IsValidIndex(idx))

		{

		iRegistered[idx]->SetFlags(aFlags);

		}

	// Also test if aControl is a layer in a transition

	idx = iActiveStack.Find(aControl->Parent());

	if(IsValidIndex(idx))

		{

		iActiveStack[idx]->SetHints(aControl, aFlags);

		return;

		}

	}

TUint CGfxTransEffect::GetHints(const CCoeControl * aControl)

	{

	// first check if it is a registered control

	TInt idx = FindRegistration(aControl);

	if(IsValidIndex(idx))

		{

		return iRegistered[idx]->Flags();

		}

	// check if it is a subcontrol in an active transition

	idx = iActiveStack.Find(aControl->Parent());

	if(IsValidIndex(idx))

		{

		return iActiveStack[idx]->GetHints(aControl);

		}

	return GfxTransEffect::ENone;

	}

void CGfxTransEffect::SetHints(const CCoeControl * aControl,TUid aLayerType)

	{

	TInt idx = iActiveStack.Find(aControl);

	if(!IsValidIndex(idx))

		{