// 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:

// mm: 

// Areas of improvement:

// * Move the CEikErrorResolver to EikSrv as it is only used there

// * Fix ineffective deprecation tags on KeyPressLabel(), Version(), and SetVerboseInfoReporting()

// * Review CCoeDataStorage

// * Make ControlStackReadyL() @internalTechnology (and rename it)

// * Check documentatoin of SetAutoForwarding()

// 

//

#include <e32uid.h>

#include <e32hal.h>

#include <basched.h>

#include <barsread.h>

#include <bautils.h>

#include "baerror.h"

#include <bassnd.h>

#include <txtrich.h>

#include <txtfmlyr.h>

#include <txtfrmat.h>

#include <mparser.h>

#include <savenotf.h>

#include <apparc.h>

#include <apgdoor.h>

#include <apgicnfl.h>

#include <apgcli.h>

#include <apgwgnam.h>

#include <prnsetup.h>

#include <gulbordr.h>

#include <gulcolor.h>

#include <gulfont.h>

#include <gulicon.h>

#include <fepbase.h>

#include <coecntrl.h>

#include <coeerror.h>

#include <coesndpy.h>

#include <eikenv.h>

#include <eikappui.h>

#include <eikdoc.h>

#include <eikapp.h>

#include <eikmsg.h>

#include <eikdebug.h>

#include <eikproc.h>

#include <eikrutil.h>

#include <eiksfont.h>

#include <eikdll.h>

#include <eiksvdef.h>

#include <eikpanic.h>

#include <uiklafgt/eikcore.rsg>

#include <uiklafgt/eikpriv.rsg>

#include <eikvcurs.h>

#include <eiksrvs.h>

#include "eikerror.h"

#include <uiklaf/private/lafshut.h>

#include <ecom/ecom.h>

#include <eikserverapp.h>

#include "EIKSRVC.H"

#include "eikdebugprefs.h"

#include "eikprivate.h"

#include "eikenvextra.h"

#include "eikautomenutitlearray.h"

#include "eikenvinterface.h"

#include <graphics/cone/coeerrorconsts.h>

#include "eikdefconst.h"

#include "eikdefconstinternal.h"

#include "EIKLIBRY.H"

#include "EIKDGFTY.H"

GLDEF_C void Panic(TEikPanic aPanic)

	{

	_LIT(KPanicCat,"EIKON");

	User::Panic(KPanicCat,aPanic);

	}

/**

@internalComponent

*/

const TUid KUikonLibraryUid = {KUidUikonLibraryValue};

/**

@internalComponent

*/

NONSHARABLE_CLASS(CEikErrorIdler) : public CIdle

	{

public:

	static CEikErrorIdler* NewL();

private:

	CEikErrorIdler() : CIdle(EPriorityLow) { }

public:

	TTime iTime;

	TInt iError;

	TInt iContext;

	};

CEikErrorIdler* CEikErrorIdler::NewL()

	{

	CEikErrorIdler* self=new(ELeave) CEikErrorIdler;

	CActiveScheduler::Add(self);

	return(self);

	}

//

// class CEikStartUpViewActivator

//

/**

This is a high-priority async view activator, used by the CEikonEnv to activate the application's 

default view on application startup in the foreground, as the view server won't do it.

@internalComponent

@see CActive

*/

NONSHARABLE_CLASS(CEikStartUpViewActivator) : public CActive

	{

public:

	static CEikStartUpViewActivator* NewL(CEikAppUi& aAppUi, CEikonEnv& aEikonEnv, CEikStartUpViewActivator*& aOwner);

	virtual ~CEikStartUpViewActivator();

private:

	CEikStartUpViewActivator(CEikAppUi& aAppUi, CEikonEnv& aEikonEnv, CEikStartUpViewActivator*& aOwner);

private: // from CActive

	void DoCancel();

	void RunL();

	TInt RunError(TInt aError);

private:

	CEikAppUi& iAppUi;

	CEikonEnv& iEnv;

	CEikStartUpViewActivator*& iOwner;

	};

const TInt KStartUpViewActivatorPriority = EActivePriorityFepLoader+10;

CEikStartUpViewActivator* CEikStartUpViewActivator::NewL(CEikAppUi& aAppUi, CEikonEnv& aEikonEnv, CEikStartUpViewActivator*& aOwner)

	{

	return new(ELeave) CEikStartUpViewActivator(aAppUi, aEikonEnv, aOwner);

	}

CEikStartUpViewActivator::~CEikStartUpViewActivator()

	{

	Cancel();

	iOwner = NULL;

	}

CEikStartUpViewActivator::CEikStartUpViewActivator(CEikAppUi& aAppUi, CEikonEnv& aEikonEnv, CEikStartUpViewActivator*& aOwner)

	: CActive(KStartUpViewActivatorPriority), iAppUi(aAppUi), iEnv(aEikonEnv), iOwner(aOwner)

	{

	CActiveScheduler::Add(this);

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

	SetActive();

	}

void CEikStartUpViewActivator::DoCancel()

	{

	}

void CEikStartUpViewActivator::RunL()

	{

	RWsSession& ws = iEnv.WsSession();

	const TInt numWgs = ws.NumWindowGroups(0);

	CArrayFixFlat<TInt>* windowList = new(ELeave) CArrayFixFlat<TInt>(numWgs);

	CleanupStack::PushL(windowList);

	ws.WindowGroupList(0, windowList);

	const TInt wgId = iEnv.RootWin().Identifier();

	if ((ws.GetFocusWindowGroup() == wgId || (windowList->Count() > 0 && windowList->At(0) == wgId))  

		&& (iEnv.IsSchedulerRunning()))

		{

		iAppUi.ActivateTopViewL();	

		}

	CleanupStack::PopAndDestroy(windowList); 	

	delete this;

	}

TInt CEikStartUpViewActivator::RunError(TInt aError)

	{

	delete this;

	return aError;

	}

//

// class CEikonEnv

//

enum TEikEnvFlags

	{

	EAutoForwarding,

	EVerboseInfoReporting,

	EStartedAsServerApp

	};

// @deprecated

EXPORT_C TVersion CEikonEnv::Version()

/** Gets the Uikon version that is currently running.

@return The Uikon version. */

    { // static

    const TInt KEikMajorVersionNumber=1;

	const TInt KEikMinorVersionNumber=0;

	const TInt KEikBuildVersionNumber=106;

    return(TVersion(KEikMajorVersionNumber,KEikMinorVersionNumber,KEikBuildVersionNumber));

    }

EXPORT_C const CFont* CEikonEnv::AnnotationFont() const

/** Gets the standard annotation font for this environment.

It is highly recommended to use CCoeControl::ScreenFont() instead of 

this function.

@see CCoeControl::ScreenFont()

@see CCoeFontProvider

@return Pointer to the annotation font. */

	{

	const TLogicalFont lf( TUid::Uid(KLafUidAnnotationFontVal) );

	return LafEnv::MatchFont(*iFontArray, lf);

	}

EXPORT_C const CFont* CEikonEnv::TitleFont() const

/** Gets the standard title font for this environment.

It is highly recommended to use CCoeControl::ScreenFont() instead of 

this function.

@see CCoeControl::ScreenFont()

@see CCoeFontProvider

@return Pointer to the title font. */

	{

	const TLogicalFont lf( TUid::Uid(KLafUidTitleFontVal) );

	return LafEnv::MatchFont(*iFontArray,lf);

	}

EXPORT_C const CFont* CEikonEnv::LegendFont() const

/** Gets the standard legend font for this environment.

It is highly recommended to use CCoeControl::ScreenFont() instead of 

this function.

@see CCoeControl::ScreenFont()

@see CCoeFontProvider

@return Pointer to the legend font. */

	{

	const TLogicalFont lf( TUid::Uid(KLafUidLegendFontVal) );

	return LafEnv::MatchFont(*iFontArray, lf);

	}

EXPORT_C const CFont* CEikonEnv::SymbolFont() const

/** Gets the standard symbol font for this environment.

It is highly recommended to use CCoeControl::ScreenFont() instead of 

this function.

@see CCoeControl::ScreenFont()

@see CCoeFontProvider

@return Pointer to the symbol font. */

	{

	const TLogicalFont lf( TUid::Uid(KLafUidSymbolFontVal) );

	return LafEnv::MatchFont(*iFontArray, lf);

	}

EXPORT_C const CFont* CEikonEnv::DenseFont() const

/** Gets the standard dense font for this environment.

It is highly recommended to use CCoeControl::ScreenFont() instead of 

this function.

@see CCoeControl::ScreenFont()

@see CCoeFontProvider

@return Pointer to the dense font. */

	{

	const TLogicalFont lf( TUid::Uid(KLafUidDenseFontVal) );

	return LafEnv::MatchFont(*iFontArray, lf);

	}

EXPORT_C const CFont* CEikonEnv::Font(const TLogicalFont& aLogicalFont) const

/** Gets the nearest match to the specified font. 

It is highly recommended to use CCoeControl::ScreenFont() instead of 

this function.

@see CCoeControl::ScreenFont()

@see CCoeFontProvider

The return value is never NULL.

@param aLogicalFont The font for which a match is sought. 

@return Pointer to the font that most closely matches aLogicalFont. */

	{

	return LafEnv::MatchFont(*iFontArray,aLogicalFont);

	}

/**

Framework function. 

Creates array of system fonts. 

*/

EXPORT_C void CEikonEnv::InitSystemFontsL()

	{

    InitSystemResourceFileL();

	InitPrivateResourceFileL();

	ASSERT(!iFontArray);

	iFontArray = new(ELeave) CArrayPtrFlat<CLafSystemFont>(2);

 	LafEnv::CreateSystemFontsL(*this,*iFontArray);

	const TLogicalFont lf( TUid::Uid(KLafUidNormalFontVal) );

	iNormalFont = LafEnv::MatchFont(*iFontArray, lf);

    }

/**

Creates and populates array of bitmaps.

@internalComponent

*/

void CEikonEnv::InitSystemBitmapsL()

	{

	ASSERT(!iBitmapArray);

	iBitmapArray = new(ELeave) CArrayPtrFlat<CFbsBitmap>(2);

	LafEnv::CreateSystemBitmapsL(*this, *iBitmapArray);

    }

EXPORT_C CEikonEnv::CEikonEnv()

/** Default C++ constructor. 

Allocates memory for the new CEikonEnv object; invoke using new(ELeave). 

The second phase constructor should be called after the constructor 

for the environment to be correctly initialised. */

    {

    }

EXPORT_C CEikonEnv::~CEikonEnv()

/** Destructor

Frees any resources allocated by this CEikonEnv during construction. */

	{

	delete iExtension;	

	BaflUtils::ReleaseIdealLanguage();

	DeleteResourceFile(iPrivateResourceFileOffset);

	delete iAppUiFactoryArray;

	delete iAutoMenuTitleArray;

	delete iSingleLineParaFormatLayer;

	delete iParaFormatLayer;

	delete iCharFormatLayer;

	delete iColorList;

	delete iLogicalBorderProxy;

	delete iLafEnv;

	CRichText::DeactivateParserDefaults();

	delete iOOMErrorText;

	if (iClockDll)

		iClockDll->Destroy();

	RApaLsSession::ClearFsSession();

	}

/**

Framework function

*/

EXPORT_C void CEikonEnv::DestroyEnvironment()

	{

	// CRichText::DeactivateParserDefaults must be called in DestroyEnvironment 

	// rather than in the destructor as internally it calls virtual functions 

	// that may (indirectly) use certain features of the CCoeEnv/CEIkonEnv 

	// object (e.g. its focus-observers)

	CRichText::DeactivateParserDefaults(); 

	User::Free(iKeyPressLabels);

	if (iAlertWin)

		iAlertWin->Release();

	iAlertWin = NULL;

	iAlertWinInitialized = EFalse;

	if (iDebugKeys)

		{

		iDebugKeys->Release();

		iDebugKeys = NULL;

		}

	delete iErrorIdler;

	iErrorIdler = NULL;

	if (iBitmapArray)

		{

		iBitmapArray->ResetAndDestroy();

		delete iBitmapArray;

		iBitmapArray = NULL;

		}

	if (iInfoMsgWin)

		{

		iInfoMsgWin->Release();

		iInfoMsgWin = NULL; // CEikonEnv::HandleError uses "!iInfoMsgWin" to test whether we are fully constructed or not, and thus whether the infra-structure is in place so that it can actually handle the error

		}

	BusyMsgCancel();

	if (!LafEnv::PolicyItem(LafEnv::ELAfEnvPolicyDeferredEnvironmentDeletion))

        {

        delete iExtension;

        iExtension = NULL; // NULL it here to prevent double-deletion of this member in ~CEikonEnv.

        }

    DeleteResourceFile(iSystemResourceFileOffset);

    // The order of destruction is important but doesn't really follow a clear logic

    // Some of the CCoeStatic are deleted before the libraries are closed because they may depend on them

    // On the other hand another set of CCoeStatic must be closed after the libraries are closed because the libraries depend on them

    // This was changed to fix a defect (DEF068403), hopefully there will be no cases where this fails, we may have to give up on trying to close 

    // everything ourselves and just let the kernel do it

    CCoeEnv::DestroyEnvironmentStatic();

    if (iFontArray)

		{

		LafEnv::ReleaseSystemFonts(*iFontArray);

		delete iFontArray;

		iFontArray = NULL;

		iNormalFont = NULL; // to prevent CCoeEnv also trying to release it

		}

    if (LafEnv::PolicyItem(LafEnv::ELAfEnvPolicyDeferredEnvironmentDeletion))

		{

		if(!iAppUi) // Ensure libraries are deleted if we get a leave before the AppUi is set 

			CloseLibraries();      

		}

    else

        CloseLibraries();      

    CCoeEnv::DestroyEnvironmentEnd();

    delete this;

    }

const TInt KUidBaflDllValue16 = 0x10003A0F; // !!! should be in BAERROR.H

/**

Handler for extended error codes.  Passes aError to AppUi for handling first.

@internalComponent

@param aError - standard error code passed in

@return - enumerated value (internalComponent - see baerrhand.h)

*/

TErrorHandlerResponse CEikonEnv::PrepareToHandleError(TInt aError)

	{

	// Note that ErrorText() and ErrorContextText() used below returns TDes reference,

	// that is used to set the texts in CCoeEnv.

	if (aError != KErrExtendedWithText)

		ErrorContextText().Zero();

	const SExtendedError& extErr = CBaActiveScheduler::ExtendedError();

	// Itterate over all AppUis (there may be nested embedded ones)

	// to allow one to override the error handling below.

	CEikAppUi* appUi = EikAppUi();

	while (appUi)

		{	

		TErrorHandlerResponse ret = appUi->HandleError(aError, extErr, ErrorText(), ErrorContextText());

		if (ret != EErrorNotHandled)	// Abort of the error was handled

			return ret;

		appUi = appUi->ContainerAppUi();

		}

	TErrorHandlerResponse ret = EAlertDisplay;

	if (aError == KErrExtendedWithText)		// Ignore the deprecated KErrExtendedWithText message

		return ret;

	// If the error was not explicitly handed by any AppUi	

   	TInt resourceId = iSystemResourceFileOffset+1-aError;

	if (aError==KErrExtended)	// Handle legacy supprt for "KErrExtended" emitted by BAFL CBaActiveScheduler

		{

		if (extErr.iInformation)

			ret = EInfoDisplay;

		resourceId = extErr.iErrorNumber;

		switch (extErr.iComponent.iUid)

			{

		case 0:

			break;

		case KUidBaflDllValue16:

			resourceId += R_EIK_BAFL_ERROR_OFFSET;

			break;

		case KUidConeDllValue16:

			resourceId += R_EIK_CONE_ERROR_OFFSET;

			break;

		case KUidBaflErrorHandlerValue:

			ret = CBaErrorHandler::CallBack(extErr.iErrorNumber, ErrorText(), ErrorContextText());

			if (ret != EErrorNotHandled)

				return ret;

			ret = EAlertDisplay; 

			//fall through

		default:

			resourceId = iSystemResourceFileOffset+1-KErrUnknown;

			}

		ReadResource(ErrorText(),resourceId);	// Read the error text from resource and set it as the error text		

		}

	else if (aError == KErrNoMemory || extErr.iErrorNumber == KErrNoMemory)

		ErrorText() = *iOOMErrorText; // use pre-allocated text, as ReadResource may try to allocate memory

	else

		GetErrorText(ErrorText(), aError);

	return ret;

	}

/** Handles an error that has occurred in the application.

It first offers the error to the app UI's HandleError() function. If that 

does not handle it, this function displays an alert window or an info 

message containing some appropriate text, read from a system resource file.