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

#include "coepanic.h"

#include <fepplugin.h>	// Needed only for deletion of iFepPlugIn member in CCoeEnvExtra::TFep

#include <hal.h>

#include "coedefkeys.h"

//

// Class CCoeEnvExtra

//

CCoeEnvExtra::CCoeEnvExtra()

	:iResFileAccessCount(2),

	 iCoeStaticList(_FOFF(CCoeStatic,iCsLink)),

	 iControlState(ETrue),

	 iArrayOfObserversOfLoadedFep(2),

	 iArrayOfFocusObservers(2),

	 iArrayOfForegroundObservers(2),

	 iArrayOfMessageObservers(2),

	 iArrayOfFepObservers(2),

	 iArrayOfResourceChangeObservers(2),

	 iArrayOfMessageMonitorObservers(2)	 

	{

	}

void CCoeEnvExtra::ConstructL()

	{

	// Short-circuit op.

	if( (KErrNone != HAL::Get( HALData::EPointerNumberOfPointers, iSupportedPointers))

	 || (0 == iSupportedPointers) )

		{

		iSupportedPointers = 1;

		}

	else if( iSupportedPointers > KConeMaxSupportedPointers )

		{

		User::Leave( KErrTooBig );

		}

	}

CCoeEnvExtra::~CCoeEnvExtra()

	{

	iArrayOfObserversOfLoadedFep.Close();

	iArrayOfFocusObservers.Close();

	iArrayOfForegroundObservers.Close();

	iArrayOfMessageObservers.Close();

	iArrayOfFepObservers.Close();

	iArrayOfResourceChangeObservers.Close();

	iArrayOfMessageMonitorObservers.Close();	

	}

void CCoeEnvExtra::HandleChangeInLoadedFep()

	{

	for (TInt i=iArrayOfObserversOfLoadedFep.Count()-1; i>=0; --i)

		{

		static_cast<MCoeObserverOfLoadedFep*>(iArrayOfObserversOfLoadedFep[i])->HandleChangeInLoadedFep();

		}

	}

void CCoeEnvExtra::NotifyFocusObserversOfChangeInFocus()

	{

	for (TInt i=iArrayOfFocusObservers.Count()-1; i>=0; --i)

		{

		static_cast<MCoeFocusObserver*>(iArrayOfFocusObservers[i])->HandleChangeInFocus();

		}

	}

void CCoeEnvExtra::NotifyFocusObserversOfDestructionOfFocusedItem()

	{

	for (TInt i=iArrayOfFocusObservers.Count()-1; i>=0; --i)

		{

		static_cast<MCoeFocusObserver*>(iArrayOfFocusObservers[i])->HandleDestructionOfFocusedItem();

		}

	}

void CCoeEnvExtra::NotifyForegroundObserversOfGainingForeground()

	{

	for (TInt i=iArrayOfForegroundObservers.Count()-1; i>=0; --i)

		{

		static_cast<MCoeForegroundObserver*>(iArrayOfForegroundObservers[i])->HandleGainingForeground();

		}

	}

void CCoeEnvExtra::NotifyForegroundObserversOfLosingForeground()

	{

	for (TInt i=iArrayOfForegroundObservers.Count()-1; i>=0; --i)

		{

		static_cast<MCoeForegroundObserver*>(iArrayOfForegroundObservers[i])->HandleLosingForeground();

		}

	}

void CCoeEnvExtra::NotifyResourceObserversOfChangeInResource()

	{

	for (TInt i=iArrayOfResourceChangeObservers.Count()-1; i>=0; --i)

		{

		static_cast<MCoeResourceChangeObserver*>(iArrayOfResourceChangeObservers[i])->HandleResourceChange();

		}

	}

void CCoeEnvExtra::NotifyMessageObserversOfMessageL(TUint32 aClientHandleOfTargetWindowGroup, const TUid& aMessageUid, const TDesC8& aMessageParameters)

	{

	TInt error=KErrNone;

	TInt previousErr=KErrNone;

	//Make this variable "volatile" to prevent the compiler putting it in a register

	volatile TInt i=iArrayOfMessageObservers.Count()-1;

	// Using two for loops like this optimizes the normal (no leave) case so that there is only one TRAP, but means that all message observers will get a chance to run, regardless of whether one of them leaves.

	for (; i>=0; --i)

		{

		TRAP(error,

			for (; i>=0; --i)

				{

				static_cast<MCoeMessageObserver*>(iArrayOfMessageObservers[i])->HandleMessageL(aClientHandleOfTargetWindowGroup, aMessageUid, aMessageParameters); // ignore the return value of HandleMessageL (which is just there in case it is needed in the future)

				}

			);

		if(previousErr==KErrNone)

			{

			previousErr=error; //Propagate the first error value if message observer leaves.

			}

		}

	User::LeaveIfError(previousErr);

	}

void CCoeEnvExtra::NotifyMessageMonitorObserversOfEvent(const TWsEvent &aEvent)

/**Systematically passes received window visibility events to the registered observers in sequence

*/

	{

	for (TInt i=iArrayOfMessageMonitorObservers.Count()-1; i>=0; --i)

		{

		static_cast<MCoeMessageMonitorObserver*>(iArrayOfMessageMonitorObservers[i])->MonitorWsMessage(aEvent); 

		}

	}

void CCoeEnvExtra::ForEachFepObserverCall(TCoeFepObserverFunction aFepObserverFunction)

	{

	for (TInt i=iArrayOfFepObservers.Count()-1; i>=0; --i)

		{

		(*aFepObserverFunction)(*(MCoeFepObserver*)iArrayOfFepObservers[i]);

		}

	}

void CCoeEnvExtra::DestroyFep(TAny* aFep)

	{

	DestroyFep(*(CCoeEnvExtra::TFep*)aFep);

	}

void CCoeEnvExtra::DestroyFep(TFep& aFep)

	{

	delete (CBase*)aFep.iFep;

	aFep.iFep=NULL;

	aFep.iFepUid=KNullUid;

	delete aFep.iFepPlugIn;

	aFep.iFepPlugIn = NULL;

	}

void CCoeEnvExtra::AddObserverL(RArray<TAny*>& aArrayOfObservers, TAny* aObserver)

	{

	__ASSERT_ALWAYS(aObserver!=NULL, Panic(ECoePanicIllegalNullParameter3));

	CleanupClosePushL(aArrayOfObservers);

	for (TInt i=aArrayOfObservers.Count()-1; i>=0; --i)

		{

		__ASSERT_ALWAYS(aArrayOfObservers[i]!=aObserver, Panic(ECoePanicFocusObserverHasAlreadyBeenAdded));

		}

	User::LeaveIfError(aArrayOfObservers.Append(aObserver));

	CleanupStack::Pop(&aArrayOfObservers);

	}

void CCoeEnvExtra::RemoveObserver(RArray<TAny*>& aArrayOfObservers, const TAny* aObserver)

	{

	__ASSERT_ALWAYS(aObserver!=NULL, Panic(ECoePanicIllegalNullParameter4));

	for (TInt i=aArrayOfObservers.Count()-1; i>=0; --i)

		{

		if (aArrayOfObservers[i]==aObserver)

			{

			aArrayOfObservers.Remove(i);

			break;

			}

		}

	}

//

// Class CCoeEnvExtra::CHighPriorityActive

//

CCoeEnvExtra::CHighPriorityActive* CCoeEnvExtra::CHighPriorityActive::NewL(CCoeEnvExtra& aCoeEnvExtra)

	{

	return new(ELeave) CHighPriorityActive(aCoeEnvExtra);

	}

CCoeEnvExtra::CHighPriorityActive::~CHighPriorityActive()

	{

	Cancel();

	}

void CCoeEnvExtra::CHighPriorityActive::QueueNotificationToFocusObserversOfChangeInFocus()

	{

	if (!IsActive())

		{

		TRequestStatus* requestStatus=&iStatus;

		User::RequestComplete(requestStatus, KErrNone);

		SetActive();

		}

	}

TInt CCoeEnvExtra::CHighPriorityActive::FocusObserverNotificationIdentifier() const

	{

	__ASSERT_DEBUG(IsActive(), Panic(ECoePanicFocusObserverNotificationIsNotPending));

	return iFocusObserverNotificationIdentifier;

	}

TBool CCoeEnvExtra::CHighPriorityActive::FocusObserverNotificationIsStillPending(TInt aFocusObserverNotificationIdentifier) const

	{

	return IsActive() && (iFocusObserverNotificationIdentifier==aFocusObserverNotificationIdentifier);

	}

CCoeEnvExtra::CHighPriorityActive::CHighPriorityActive(CCoeEnvExtra& aCoeEnvExtra)

	:CActive(EActivePriorityWsEvents+50), // this priority must be greater than CCoeFep::CHighPriorityActive's priority (a FEPBASE class) so that FEPs receive notification of any change in focus (resulting from them calling HandleStartOfTransactionL) *before* any deferred function (i.e. one overriding MDeferredFunctionCall::ExecuteFunctionL) is called - this is necessary as the deferred function may depend on the deferred capabilities of the newly focused control (e.g. for inline editing)

	 iCoeEnvExtra(aCoeEnvExtra),

	 iFocusObserverNotificationIdentifier(0)

	{

	CActiveScheduler::Add(this);

	}

void CCoeEnvExtra::CHighPriorityActive::DoCancel()

	{

	}

void CCoeEnvExtra::CHighPriorityActive::RunL()

	{

	NotifyFocusObserversOfChangeInFocus();

	}

void CCoeEnvExtra::CHighPriorityActive::NotifyFocusObserversOfChangeInFocus()

	{

    iCoeEnvExtra.NotifyFocusObserversOfChangeInFocus();

    ++iFocusObserverNotificationIdentifier;

	}

/** Default Constructor for TScreenItem

*/

CCoeEnvExtra::CScreenItem::CScreenItem(CWsScreenDevice* aScreenDevice, RWindowGroup* aWindowGroup)

		:iScreenDevice(aScreenDevice),iWindowGroup(aWindowGroup)

	{

	}

CCoeEnvExtra::CScreenItem::~CScreenItem()

	{

	delete iScreenDevice;

	if (iWindowGroup)

		iWindowGroup->Close();

	delete iWindowGroup;

	}

/**

@return The screen device

*/

CWsScreenDevice* CCoeEnvExtra::CScreenItem::ScreenDevice()

	{

	return iScreenDevice;	

	}

/**

@return The window group

*/

RWindowGroup* CCoeEnvExtra::CScreenItem::WindowGroup()

	{

	return iWindowGroup;	

	}

/**

This function is used only to set the value of iArrayOfScreenItems's first entry's iScreenDevice to NULL. 

The data to which the first entry points to cannot be deleted in DeleteArrayOfScreensItems.

*/

void CCoeEnvExtra::CScreenItem::SetScreenDevice(CWsScreenDevice* aScreenDevice)

	{

	iScreenDevice = aScreenDevice;	

	}

/**

This function is used only to set the value of iArrayOfScreenItems's first entry's iWindowGroup to NULL.

The data to which the first entry points to cannot be deleted in DeleteArrayOfScreensItems.

*/	

void CCoeEnvExtra::CScreenItem::SetWindowGroup(RWindowGroup* aWindowGroup)

	{

	iWindowGroup = aWindowGroup;	

	}