// 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 <f32file.h>

#include <s32stor.h>

#include <s32file.h>

#include <coemain.h>

#include "coepriv.h"

#include "COETLS.H"

#include "COEFEP.H"		// class FepName

#include "coepanic.h"

#include "coever.h"

#include <coecntrl.h>

#include <coeerror.h>

#include "coeenvextra.h"

#include <barsread.h>

#include <bautils.h>

#include <viewcli.h>

#include <coeaui.h>

#include <hal.h>

#include "coedatastorage.h"

#include <coefontprovider.h>

#include <centralrepository.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <viewclipartner.h>

#endif

#include "coescheduler.h"

#include "coeerrorconsts.h"

#include "coedefkeys.h"

//#define CONE_SHOW_TRACE			

#ifdef CONE_SHOW_TRACE

void ShowTrace(TRefByValue<const TDesC> aFmt,...)

	{

	RDebug::Print(aFmt);

	}

#else

void ShowTrace(TRefByValue<const TDesC> /*aFmt*/,...)

	{

	}

#endif

/**

ROM-patchable constant for turning the automatic setting of the CCoeControl's

parent-pointer on or off. Only available in Symbian OS 9.3 and 9.4.

@publishedPartner

*/

//#if !defined(SYMBIAN_WSERV_AND_CONE_MULTIPLE_SCREENS)

EXPORT_C extern const TInt KCoeSetControlParentByDefault = ETrue;	// Used in CCoeControlStaticSettings::ParentByDefault()

//#endif

_LIT(KSystemFont,"Arial");

const TInt KDefaultScreenNumber = 0 ; // If no startup screen is defined at construction use this.

GLDEF_C void Panic(TCoePanic aPanic)

	{

	_LIT(KPanicCone,"CONE");

	User::Panic(KPanicCone,aPanic);

	}

LOCAL_C TBool IsHandleValid(TUint aHandle)

	{

	return (aHandle&3)==0;

	}

//

// Synchronously notifies focus observers of a focus change so

// they can be reset after they receive a focus change event 

// 

// @since	6.1

//

EXPORT_C void CCoeEnv::SyncNotifyFocusObserversOfChangeInFocus()

	{

	iExtra->iHighPriorityActive->NotifyFocusObserversOfChangeInFocus();

	iExtra->iHighPriorityActive->Cancel();

	}

//

// Class CCoeScheduler

//

EXPORT_C CCoeScheduler::CCoeScheduler(CCoeEnv* aCoeEnv)

/** Constructor taking a pointer to the control environment.

@param aCoeEnv The control environment. */

	{

	iCoeEnv=aCoeEnv;

	iFlush=ETrue; // Set the default flushing behaviour to flush automatically

	}

EXPORT_C void CCoeScheduler::WaitForAnyRequest()

/** Waits for an asynchronous request to complete. */

	{

	iCoeEnv->DoFlush();

	CBaActiveScheduler::WaitForAnyRequest();

	}

EXPORT_C void CCoeScheduler::DisplayError(TInt aError) const

/** Displays an application-defined error message.

@param aError An error code. */

	{

	iCoeEnv->HandleError(aError);

	}

TBool CCoeScheduler::Flush() const

	{

	return iFlush;

	}

void CCoeScheduler::SetFlush(TBool aFlush)

	{

	iFlush=aFlush;

	}

EXPORT_C void CCoeScheduler::Reserved_1()

	{

	}

EXPORT_C void CCoeScheduler::Reserved_2()

	{

	}

//

// Class CCoeEnv

//

EXPORT_C TBool CCoeEnv::DisableShutdownChecks() const

	{

	return iEnvFlags&ENoShutdownChecks;

	}

inline TUint CCoeEnv::InitialHandleCount() const

	{return (iEnvFlags&0xffff0000)>>16;}

TInt CCoeEnv::SupportedPointers() const

	{

	return iExtra->iSupportedPointers;

	}

const TInt KErrorContextTextLength=80;

const TInt KErrorTextLength=80;

EXPORT_C CCoeEnv::CCoeEnv() : CActive(EActivePriorityWsEvents)

/** Default constructor.

Note - Construction of the CCoeEnv is not complete 

until ConstructL() has been called.

This function raises a CONE 2 panic if the application already owns a CCoeEnv. */

	{

	TInt error=KErrNone;

#ifdef _DEBUG

	HAL::SEntry* pE=NULL;

	TInt entries=0;

	if (error==KErrNone)

		error=HAL::GetAll(entries, pE);

	User::Free(pE);

	SetInitialHandleCount();

#endif

	__ASSERT_ALWAYS(!TheCoe(),Panic(ECoePanicEnvironmentAlreadyExists));

	if (error==KErrNone)

		error=SetTheCoe(this);

	__UHEAP_MARK;

	iCleanup=CTrapCleanup::New();

	if ((iCleanup==NULL) && (error==KErrNone))

		error=KErrNoMemory;

	if (error!=KErrNone)

		{

		iExtra=REINTERPRET_CAST(CCoeEnvExtra*, error);

		iEnvFlags|=EExtraPointerIsErrorCode;

		}

	}

EXPORT_C void CCoeEnv::ExecuteD()

/** Launches the application and destroys the control environment. */ 

	{

	Execute();

	DestroyEnvironment();

	}

EXPORT_C void CCoeEnv::Execute()

/** Launches the application without destroying the control environment. 

This function starts the active scheduler owned by the CCoeEnv, enabling the 

application to start receiving events from the window server. It forms the 

outer loop of all Control Environment applications. */

	{

	iEnvFlags|=ESchedulerIsRunning;

	TRAPD(exitCondition,CActiveScheduler::Start());

	__ASSERT_ALWAYS((exitCondition==KLeaveExit) || (exitCondition==KErrNone), Panic(ECoePanicLeaveWithoutTrap));

	PrepareToExit();

	}

EXPORT_C void CCoeEnv::PrepareToExit()

/** Prepares for exiting the application. 

The function is called from ExecuteD() after the active scheduler's wait loop 

terminates, but before the environment is destroyed. */

	{

	if (iAppUi)

		iAppUi->PrepareToExit();

	}

EXPORT_C void CCoeEnv::RunL()

	{

	switch (iStatus.Int())

		{

	case KErrNone:

		break;

	case KErrCancel:

	case KErrServerTerminated:

		return;

	default:

#ifdef _DEBUG

	    RDebug::Print( _L("CCoeEnv's iStatus = %d"), iStatus.Int() );

#endif

		Panic(ECoePanicWservBlindCommandFailed);

		}

	TWsEvent event;

	iWsSession.GetEvent(event);

	RequestEventNotification();		//Request now so that WSERV has time to respond (on SMP systems) before the return to the Active Scheduler

	const TUint handle=event.Handle();

	if (handle)

		{

		CCoeControl* const window=IsHandleValid(handle)? reinterpret_cast<CCoeControl*>(handle) : NULL;

		iLastEvent=event;

		iAppUi->MonitorWsEvent(event);

		//coverity[var_deref_model]

		//Passing a NULL value of window to this function is allowed because the window is not always dereferenced by this function. 

		//The window will not be NULL if it is to be dereferenced by this function. 

		iAppUi->HandleWsEventL(event,window);

		}

	}

EXPORT_C void CCoeEnv::SimulateKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)

/** Simulates a key event.

This function calls CCoeAppUi::HandleWsEventL() to process the event 

as if it had arrived from the window server.

@param aKeyEvent The key event.

@param aType The event type. */

	{

	TWsEvent event;

	*event.Key()=aKeyEvent;

	event.SetType(aType);

	event.SetTimeNow();

	iLastEvent=event;

	iAppUi->HandleWsEventL(event,NULL);

	}

EXPORT_C void CCoeEnv::DoCancel()

	{

	iWsSession.EventReadyCancel();

	}

EXPORT_C void CCoeEnv::SuppressNextFlush()

/** Suppresses the next flush of the active scheduler queue. 

It prevents the active scheduler automatically flushing its window server 

session the next time that a non-CCoeEnv object runs. After the active object 

has run, the active scheduler reverts back to its normal behaviour, flushing 

after each non-CCoeEnv RunL(). */

	{

	static_cast<CCoeScheduler*>(CActiveScheduler::Current())->SetFlush(EFalse);

	}

void CCoeEnv::DoFlush()

/** Flush WSERV's command buffer */

	{

	CCoeScheduler* coeScheduler=static_cast<CCoeScheduler*>(CActiveScheduler::Current());

	if (coeScheduler->Flush())

		iWsSession.Flush();

	else

		coeScheduler->SetFlush(ETrue);

	}

void CCoeEnv::RequestEventNotification()

/** Asks WSERV to give notification when an event is waiting */

	{

	iWsSession.EventReady(&iStatus);

	SetActive();

	}

CVwsSessionWrapper* CCoeEnv::InitViewServerSessionL(MVwsSessionWrapperObserver& aObserver)

	{

	if (!(iExtra->iVwsSession))

		{

		iExtra->iVwsSession=CVwsSessionWrapper::NewL(aObserver);

		}

	return iExtra->iVwsSession;

	}

EXPORT_C void CCoeEnv::HandleError(TInt /*aErrorValue*/)

/** Handles an application-defined error message.

This function allows application-defined error messages to be called from 

functions within the control framework's active scheduler. It has an empty 

default implementation.

It is called when a leave occurs in CCoeEnv::RunL(), and also when ReadResource() 

fails.

@param aErrorValue KErrNone or another error code. */

	{

	}

EXPORT_C void CCoeEnv::BringOwnerToFront()

/** Brings the application's owning window group to the front of the screen and 

gives it keyboard focus. 

This is done by giving the owning window group an ordinal position of zero. */

	{

	if (iRootWin.WsHandle()) // else initialization hasn't got that far yet

		iRootWin.SetOrdinalPosition(KOrdinalPositionSwitchToOwningWindow);

	}

EXPORT_C void CCoeEnv::DestroyEnvironment()

/** Deletes several resources owned by the CCoeEnv object.

This includes; the app UI, the system graphics context, and the active object 

which receives redraw events. It also closes the window group, the connection 

to the window server, and the connection to the file server.

The function is called from ExecuteD() when the active scheduler's wait loop 

terminates. */

	{

	iExtra->iControlState = EFalse;

	DestroyEnvironmentStatic();

	DestroyEnvironmentEnd();

	delete this;

	}

/** @internalTechnology */

EXPORT_C void CCoeEnv::DestroyEnvironmentStatic()

	{

	BringOwnerToFront();

	const TBool extraIsNonNull=(!(iEnvFlags&EExtraPointerIsErrorCode) && (iExtra!=NULL));

	if (extraIsNonNull)

		{

		CCoeEnvExtra::DestroyFep(iExtra->iFep);

		// Delete all CCoeStatics with positive destruction priority

		TDblQueIter<CCoeStatic> iter(iExtra->iCoeStaticList);

		iter.SetToFirst();

		CCoeStatic* coeStatic = NULL;

		while (((coeStatic=iter++)!=NULL) && (coeStatic->DestructionPriority()>=0))

			{

			delete coeStatic;

			}

		}

	}	

/** @internalTechnology */

EXPORT_C void CCoeEnv::DestroyEnvironmentEnd()

	{

	const TBool extraIsNonNull=(!(iEnvFlags&EExtraPointerIsErrorCode) && (iExtra!=NULL));	

	delete(iAppUi); // must be destroyed before the iExtra observers

	iAppUi=NULL;

	if (extraIsNonNull)

		{

		delete iExtra->iFepTracker; // this must be deleted *before* the CCoeDataStorage object - the latter is deleted by one of the CCoeStatic objects (with negative destruction priority) below

		// Delete all CCoeStatics with negative destruction priority

		TDblQueIter<CCoeStatic> iter(iExtra->iCoeStaticList);

		iter.SetToFirst();

		CCoeStatic* coeStatic = NULL;

		while ((coeStatic=iter++)!=NULL)

			{

			delete coeStatic;

			}

		DeleteArrayOfScreensItems();

		delete iExtra->iRedrawer;

		delete iExtra->iFepLoader;

		delete iExtra->iVwsSession;

		delete iExtra->iDefaultFontProvider; 

		delete iExtra->iDefaultTextDrawer;

		}

	delete(iSystemGc);

	ReleaseScreenFont(CONST_CAST(CFont*,iNormalFont));

	DestroyScreen(); // this is a virtual function so it must be called here rather than in CCoeEnv's destructor

	iRootWin.Close();

	Cancel();

	}

#if defined(_DEBUG)

template <class T, class R>

TInt FindAllThreadHandles(T& aFindHandle)

	{

	_LIT(KFormatString,"%S::*");

	RThread t;

	TFullName name;

	const TFullName threadName=t.FullName();

	name.Format(KFormatString,&threadName);

	aFindHandle.Find(name);

	TInt count=0;

	FOREVER

		{

		const TInt r=aFindHandle.Next(name);

		if (r!=KErrNone)

			break;

		count++;

		ShowTrace(_L("%S"), &name);

		}

	return count;

	}

void IdentifyOpenHandles1()

	{

	TFindSemaphore sem;

	ShowTrace(_L("Finding open semaphores..."));

	FindAllThreadHandles<TFindSemaphore, RSemaphore>(sem);

	}

void IdentifyOpenHandles2()

	{

	TFindMutex mux;

	ShowTrace(_L("Finding open mutexes..."));

	FindAllThreadHandles<TFindMutex, RMutex>(mux);

	}

void IdentifyOpenHandles3()

	{

	TFindChunk fchunk;

	ShowTrace(_L("Finding open chunks..."));

	FindAllThreadHandles<TFindChunk, RChunk>(fchunk);

	}

void IdentifyOpenHandles4()

	{

	TFindLogicalDevice fldev;

	ShowTrace(_L("Finding open logical devices..."));

	FindAllThreadHandles<TFindLogicalDevice, RDevice>(fldev);

	}

LOCAL_C void IdentifyOpenHandles()

	{

	ShowTrace(_L("Open handles found during thread %Lu shutdown"), RThread().Id().Id()); // %Lu is used for a TUint64

	IdentifyOpenHandles1();

	IdentifyOpenHandles2();

	IdentifyOpenHandles3();

	IdentifyOpenHandles4();

	ShowTrace(_L("Finished attempts to identify handles"));

	Panic(ECoePanicHandleNotClosed);

	}

#endif

EXPORT_C CCoeEnv::~CCoeEnv()

/** Destructor. 

This function deletes any resources owned by the CCoeEnv that were not deleted 

by DestroyEnvironment(). */

	{

	if (!(iEnvFlags&EExtraPointerIsErrorCode) && (iExtra!=NULL))

		{

		delete iExtra->iHighPriorityActive;

#if defined(_DEBUG)

		if (iResourceFileArray!=NULL)

			{

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

				{

				ShowTrace(_L("Resource file with offset 0x%08x has been leaked (search for the 4 most significant hexadecimal digits of this number in epoc32\\include\\*.RSG to find out which resource file)"), (*iResourceFileArray)[i].Offset());

				}

			__ASSERT_DEBUG(iResourceFileArray->Count()==0,Panic(ECoePanicResourceFileNotDeleted));

			}

#endif

		__ASSERT_DEBUG(iExtra->iResFileAccessCount.Count()==0,Panic(ECoePanicResourceFileNotDeleted));

		iExtra->iResFileAccessCount.Close();

		delete iExtra; // can only be done when iAppUi has been destroyed as destroying iAppUi may destroy some controls owned by the control stack, and these controls may call SetFocus when they are destroyed, SetFocus internally referencing iExtra->iNumberOfNestedSetFocusCalls

		}

	DestroyAllResourceFiles();

	delete iScreen;

	delete CActiveScheduler::Current();

	delete iErrorText;

	delete iErrorContextText;

	delete iCleanup;

	__ASSERT_DEBUG(DisableShutdownChecks() || (iWsSession.Handle()==KNullHandle) || (iWsSession.ResourceCount()==0),Panic(ECoePanicWservResourceNotFreed));

	iWsSession.Close();

	// Checks that less than 1 file is open. 1 file may be open because the RFbs keeps one file cached.

	// A defect has been raised to change this.

	__ASSERT_DEBUG(DisableShutdownChecks() || (iFsSession.Handle()==KNullHandle) || (iFsSession.ResourceCount()<=1),Panic(ECoePanicF32ResourceNotFreed));

	iFsSession.Close();

	REComSession::FinalClose();

#if defined(_DEBUG)

	if (!DisableShutdownChecks())

		{

		__UHEAP_MARKEND;

		TInt processHandleCount=0;

		TInt threadHandleCount=0;

		RThread().HandleCount(processHandleCount,threadHandleCount);

		const TInt initialHandleCount=InitialHandleCount();

		if (threadHandleCount>initialHandleCount && initialHandleCount<KMaxTInt16)

			{

			IdentifyOpenHandles();

			}

		}

#endif

	FreeTheCoe();

	}

EXPORT_C void CCoeEnv::DestroyScreen()

/** Destroys the screen device.

By default this function simply deletes the screen device owned by this CCoeEnv. 

However, this function may be overridden by subclasses.