1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include <f32file.h>

    17 #include <s32stor.h>

    18 #include <s32file.h>

    19 #include <coemain.h>

    20 #include "coepriv.h"

    21 #include "COETLS.H"

    22 #include "COEFEP.H"		// class FepName

    23 #include "coepanic.h"

    24 #include "coever.h"

    25 #include <coecntrl.h>

    26 #include <coeerror.h>

    27 #include "coeenvextra.h"

    28 #include <barsread.h>

    29 #include <bautils.h>

    30 #include <viewcli.h>

    31 #include <coeaui.h>

    32 #include <hal.h>

    33 #include "coedatastorage.h"

    34 #include <coefontprovider.h>

    35 #include <centralrepository.h>

    36 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    37 #include <viewclipartner.h>

    38 #endif

    39 #include "coescheduler.h"

    40 #include "coeerrorconsts.h"

    41 #include "coedefkeys.h"

    42 

    43 

    44 //#define CONE_SHOW_TRACE			

    45 

    46 #ifdef CONE_SHOW_TRACE

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

    48 	{

    49 	RDebug::Print(aFmt);

    50 	}

    51 #else

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

    53 	{

    54 	}

    55 #endif

    56 

    57 /**

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

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

    60 @publishedPartner

    61 */

    62 //#if !defined(SYMBIAN_WSERV_AND_CONE_MULTIPLE_SCREENS)

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

    64 //#endif

    65 

    66 _LIT(KSystemFont,"Arial");

    67 

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

    69 

    70 GLDEF_C void Panic(TCoePanic aPanic)

    71 	{

    72 	_LIT(KPanicCone,"CONE");

    73 	User::Panic(KPanicCone,aPanic);

    74 	}

    75 

    76 

    77 LOCAL_C TBool IsHandleValid(TUint aHandle)

    78 	{

    79 	return (aHandle&3)==0;

    80 	}

    81 

    82 //

    83 // Synchronously notifies focus observers of a focus change so

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

    85 // 

    86 // @since	6.1

    87 //

    88 EXPORT_C void CCoeEnv::SyncNotifyFocusObserversOfChangeInFocus()

    89 	{

    90 	iExtra->iHighPriorityActive->NotifyFocusObserversOfChangeInFocus();

    91 	iExtra->iHighPriorityActive->Cancel();

    92 	}

    93 

    94 

    95 //

    96 // Class CCoeScheduler

    97 //

    98 

    99 EXPORT_C CCoeScheduler::CCoeScheduler(CCoeEnv* aCoeEnv)

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

   101 

   102 @param aCoeEnv The control environment. */

   103 	{

   104 	iCoeEnv=aCoeEnv;

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

   106 	}

   107 

   108 EXPORT_C void CCoeScheduler::WaitForAnyRequest()

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

   110 	{

   111 	iCoeEnv->DoFlush();

   112 	CBaActiveScheduler::WaitForAnyRequest();

   113 	}

   114 

   115 EXPORT_C void CCoeScheduler::DisplayError(TInt aError) const

   116 /** Displays an application-defined error message.

   117 

   118 @param aError An error code. */

   119 	{

   120 	iCoeEnv->HandleError(aError);

   121 	}

   122 

   123 TBool CCoeScheduler::Flush() const

   124 	{

   125 	return iFlush;

   126 	}

   127 

   128 void CCoeScheduler::SetFlush(TBool aFlush)

   129 	{

   130 	iFlush=aFlush;

   131 	}

   132 

   133 EXPORT_C void CCoeScheduler::Reserved_1()

   134 	{

   135 	}

   136 

   137 EXPORT_C void CCoeScheduler::Reserved_2()

   138 	{

   139 	}

   140 

   141 //

   142 // Class CCoeEnv

   143 //

   144 EXPORT_C TBool CCoeEnv::DisableShutdownChecks() const

   145 	{

   146 	return iEnvFlags&ENoShutdownChecks;

   147 	}

   148 	

   149 inline TUint CCoeEnv::InitialHandleCount() const

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

   151 

   152 TInt CCoeEnv::SupportedPointers() const

   153 	{

   154 	return iExtra->iSupportedPointers;

   155 	}

   156 

   157 const TInt KErrorContextTextLength=80;

   158 const TInt KErrorTextLength=80;

   159 

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

   161 /** Default constructor.

   162 

   163 Note - Construction of the CCoeEnv is not complete 

   164 until ConstructL() has been called.

   165 

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

   167 	{

   168 	TInt error=KErrNone;

   169 #ifdef _DEBUG

   170 	HAL::SEntry* pE=NULL;

   171 	TInt entries=0;

   172 	if (error==KErrNone)

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

   174 	

   175 	User::Free(pE);

   176 	SetInitialHandleCount();

   177 #endif

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

   179 	if (error==KErrNone)

   180 		error=SetTheCoe(this);

   181 	__UHEAP_MARK;

   182 	

   183 	iCleanup=CTrapCleanup::New();

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

   185 		error=KErrNoMemory;

   186 		

   187 	if (error!=KErrNone)

   188 		{

   189 		iExtra=REINTERPRET_CAST(CCoeEnvExtra*, error);

   190 		iEnvFlags|=EExtraPointerIsErrorCode;

   191 		}

   192 	}

   193 

   194 EXPORT_C void CCoeEnv::ExecuteD()

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

   196 	{

   197 	Execute();

   198 	DestroyEnvironment();

   199 	}

   200 

   201 EXPORT_C void CCoeEnv::Execute()

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

   203 

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

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

   206 outer loop of all Control Environment applications. */

   207 	{

   208 	iEnvFlags|=ESchedulerIsRunning;

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

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

   211 	PrepareToExit();

   212 	}

   213 

   214 EXPORT_C void CCoeEnv::PrepareToExit()

   215 /** Prepares for exiting the application. 

   216 

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

   218 terminates, but before the environment is destroyed. */

   219 	{

   220 	if (iAppUi)

   221 		iAppUi->PrepareToExit();

   222 	}

   223 

   224 EXPORT_C void CCoeEnv::RunL()

   225 	{

   226 	switch (iStatus.Int())

   227 		{

   228 	case KErrNone:

   229 		break;

   230 	case KErrCancel:

   231 	case KErrServerTerminated:

   232 		return;

   233 	default:

   234 		Panic(ECoePanicWservBlindCommandFailed);

   235 		}

   236 	TWsEvent event;

   237 	iWsSession.GetEvent(event);

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

   239 	const TUint handle=event.Handle();

   240 	if (handle)

   241 		{

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

   243 		iLastEvent=event;

   244 		iAppUi->MonitorWsEvent(event);

   245 		//coverity[var_deref_model]

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

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

   248 		iAppUi->HandleWsEventL(event,window);

   249 		}

   250 	}

   251 

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

   253 /** Simulates a key event.

   254 

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

   256 as if it had arrived from the window server.

   257 

   258 @param aKeyEvent The key event.

   259 @param aType The event type. */

   260 	{

   261 	TWsEvent event;

   262 	*event.Key()=aKeyEvent;

   263 	event.SetType(aType);

   264 	event.SetTimeNow();

   265 	iLastEvent=event;

   266 	iAppUi->HandleWsEventL(event,NULL);

   267 	}

   268 

   269 EXPORT_C void CCoeEnv::DoCancel()

   270 	{

   271 	iWsSession.EventReadyCancel();

   272 	}

   273 

   274 EXPORT_C void CCoeEnv::SuppressNextFlush()

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

   276 

   277 It prevents the active scheduler automatically flushing its window server 

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

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

   280 after each non-CCoeEnv RunL(). */

   281 	{

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

   283 	}

   284 

   285 void CCoeEnv::DoFlush()

   286 /** Flush WSERV's command buffer */

   287 	{

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

   289 	if (coeScheduler->Flush())

   290 		iWsSession.Flush();

   291 	else

   292 		coeScheduler->SetFlush(ETrue);

   293 	}

   294 

   295 void CCoeEnv::RequestEventNotification()

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

   297 	{

   298 	iWsSession.EventReady(&iStatus);

   299 	SetActive();

   300 	}

   301 

   302 CVwsSessionWrapper* CCoeEnv::InitViewServerSessionL(MVwsSessionWrapperObserver& aObserver)

   303 	{

   304 	if (!(iExtra->iVwsSession))

   305 		{

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

   307 		}

   308 	return iExtra->iVwsSession;

   309 	}

   310 

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

   312 /** Handles an application-defined error message.

   313 

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

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

   316 default implementation.

   317 

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

   319 fails.

   320 

   321 @param aErrorValue KErrNone or another error code. */

   322 	{

   323 	}

   324 

   325 EXPORT_C void CCoeEnv::BringOwnerToFront()

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

   327 gives it keyboard focus. 

   328 

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

   330 	{

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

   332 		iRootWin.SetOrdinalPosition(KOrdinalPositionSwitchToOwningWindow);

   333 	}

   334 

   335 EXPORT_C void CCoeEnv::DestroyEnvironment()

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

   337 

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

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

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

   341 

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

   343 terminates. */

   344 	{

   345 	iExtra->iControlState = EFalse;

   346 	DestroyEnvironmentStatic();

   347 	DestroyEnvironmentEnd();

   348 	delete this;

   349 	}

   350 	

   351 /** @internalTechnology */

   352 EXPORT_C void CCoeEnv::DestroyEnvironmentStatic()

   353 	{

   354 	BringOwnerToFront();

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

   356 	if (extraIsNonNull)

   357 		{

   358 		CCoeEnvExtra::DestroyFep(iExtra->iFep);

   359 

   360 		// Delete all CCoeStatics with positive destruction priority

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

   362 		iter.SetToFirst();

   363 		CCoeStatic* coeStatic = NULL;

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

   365 			{

   366 			delete coeStatic;

   367 			}

   368 		}

   369 	}	

   370 	

   371 /** @internalTechnology */

   372 EXPORT_C void CCoeEnv::DestroyEnvironmentEnd()

   373 	{

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

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

   376 	iAppUi=NULL;

   377 	if (extraIsNonNull)

   378 		{

   379 		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

   380 

   381 		// Delete all CCoeStatics with negative destruction priority

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

   383 		iter.SetToFirst();

   384 		CCoeStatic* coeStatic = NULL;

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

   386 			{

   387 			delete coeStatic;

   388 			}

   389 		DeleteArrayOfScreensItems();

   390 		delete iExtra->iRedrawer;

   391 		delete iExtra->iFepLoader;

   392 		delete iExtra->iVwsSession;

   393 		delete iExtra->iDefaultFontProvider; 

   394 		delete iExtra->iDefaultTextDrawer;

   395 		}

   396 	delete(iSystemGc);

   397 	ReleaseScreenFont(CONST_CAST(CFont*,iNormalFont));

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

   399 	iRootWin.Close();

   400 	Cancel();

   401 	}

   402 

   403 #if defined(_DEBUG)

   404 

   405 template <class T, class R>

   406 TInt FindAllThreadHandles(T& aFindHandle)

   407 	{

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

   409 	RThread t;

   410 	TFullName name;

   411 	const TFullName threadName=t.FullName();

   412 	name.Format(KFormatString,&threadName);

   413 	aFindHandle.Find(name);

   414 	TInt count=0;

   415 	FOREVER

   416 		{

   417 		const TInt r=aFindHandle.Next(name);

   418 		if (r!=KErrNone)

   419 			break;

   420 		count++;

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

   422 		}

   423 	return count;

   424 	}

   425 

   426 void IdentifyOpenHandles1()

   427 	{

   428 	TFindSemaphore sem;

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

   430 	FindAllThreadHandles<TFindSemaphore, RSemaphore>(sem);

   431 	}

   432 

   433 void IdentifyOpenHandles2()

   434 	{

   435 	TFindMutex mux;

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

   437 	FindAllThreadHandles<TFindMutex, RMutex>(mux);

   438 	}

   439 

   440 void IdentifyOpenHandles3()

   441 	{

   442 	TFindChunk fchunk;

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

   444 	FindAllThreadHandles<TFindChunk, RChunk>(fchunk);

   445 	}

   446 

   447 void IdentifyOpenHandles4()

   448 	{

   449 	TFindLogicalDevice fldev;

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

   451 	FindAllThreadHandles<TFindLogicalDevice, RDevice>(fldev);

   452 	}

   453 

   454 LOCAL_C void IdentifyOpenHandles()

   455 	{

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

   457 	IdentifyOpenHandles1();

   458 	IdentifyOpenHandles2();

   459 	IdentifyOpenHandles3();

   460 	IdentifyOpenHandles4();

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

   462 	Panic(ECoePanicHandleNotClosed);

   463 	}

   464 

   465 #endif

   466 

   467 EXPORT_C CCoeEnv::~CCoeEnv()

   468 /** Destructor. 

   469 

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

   471 by DestroyEnvironment(). */

   472 	{

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

   474 		{

   475 		delete iExtra->iHighPriorityActive;

   476 #if defined(_DEBUG)

   477 		if (iResourceFileArray!=NULL)

   478 			{

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

   480 				{

   481 				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());

   482 				}

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

   484 			}

   485 #endif

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

   487 		iExtra->iResFileAccessCount.Close();

   488 		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

   489 		}

   490 	DestroyAllResourceFiles();

   491 	delete iScreen;

   492 	delete CActiveScheduler::Current();

   493 	delete iErrorText;

   494 	delete iErrorContextText;

   495 	delete iCleanup;

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

   497 	iWsSession.Close();

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

   499 	// A defect has been raised to change this.

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

   501 	iFsSession.Close();

   502 	REComSession::FinalClose();

   503 #if defined(_DEBUG)

   504 	if (!DisableShutdownChecks())

   505 		{

   506 		__UHEAP_MARKEND;

   507 		TInt processHandleCount=0;

   508 		TInt threadHandleCount=0;

   509 		RThread().HandleCount(processHandleCount,threadHandleCount);

   510 		const TInt initialHandleCount=InitialHandleCount();

   511 		if (threadHandleCount>initialHandleCount && initialHandleCount<KMaxTInt16)

   512 			{

   513 			IdentifyOpenHandles();

   514 			}

   515 		}

   516 #endif

   517 	FreeTheCoe();

   518 	}

   519 

   520 EXPORT_C void CCoeEnv::DestroyScreen()

   521 /** Destroys the screen device.

   522 

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

   524 However, this function may be overridden by subclasses.

   525 

   526 This function is called by DestroyEnvironment(). */

   527 	{ // subclassers can do more

   528 	}

   529 

   530 EXPORT_C CCoeAppUi* CCoeEnv::SetAppUi(CCoeAppUi* aAppUi)

   531 /** Sets the application's user interface object.

   532 

   533 Standard GUI applications do not need to call this function, as the framework 

   534 sets the app UI, during start up, to be the CEikAppUi-derived object created 

   535 by the application.

   536 

   537 @param aAppUi The app UI for this application.

   538 @return The app UI previously owned by this application, or NULL if this is 

   539 the first time its app UI has been set. */

   540 	{

   541 	CCoeAppUi* previous=iAppUi;

   542 	iAppUi=aAppUi;

   543 	if (previous==NULL) // i.e. we've only just set the app ui for the first time

   544 		{

   545 		UpdateStatic(aAppUi);

   546 		}

   547 	return(previous);

   548 	}

   549 

   550 EXPORT_C void CCoeEnv::ConstructL()

   551 /** Completes construction of the CCoeEnv object.

   552 

   553 It calls the other ConstructL() overload specifying ETrue as the initial 

   554 focus state. */

   555 	{

   556 	ConstructL(ETrue);

   557 	}

   558 

   559 EXPORT_C void CCoeEnv::ConstructL(TBool aInitialFocusState)

   560 /** Completes construction of the CCoeEnv. 

   561 

   562 It is called by the other overload, with aInitialFocusState set to ETrue.

   563 

   564 

   565 @param aInitialFocusState Window group initial focus state. If ETrue, keyboard 

   566 focus is enabled, otherwise keyboard focus is disabled. */

   567 	{

   568 	ConstructL( aInitialFocusState, KDefaultScreenNumber ) ;

   569 	}

   570 

   571 /** Completes construction of the CCoeEnv. 

   572 It can be called by the previous overload.  It calls the next overload, setting

   573 the default window group ID to 0 which is not a valid ID

   574 

   575 @param aInitialFocusState Window group initial focus state. If ETrue, keyboard 

   576 focus is enabled, otherwise keyboard focus is disabled. 

   577 @param aDefaultScreenNumber The default screen number should be zero.*/

   578 EXPORT_C void CCoeEnv::ConstructL( TBool aInitialFocusState, TInt aDefaultScreenNumber ) // Added May 04 support for Multiple Screens

   579 

   580 	{

   581 	ConstructL(aInitialFocusState, aDefaultScreenNumber, 0); // 0 is not a valid window group ID

   582 	}

   583 

   584 /** Completes construction of the CCoeEnv. 

   585 

   586 All of the previous ConstructL() overloads end up at this method.

   587 

   588 This function creates an active scheduler, and adds active objects to it for 

   589 standard and redraw events. The active scheduler is not started, however, 

   590 and no events are received, until ExecuteD() is called. It also does the following:

   591 

   592 - creates a connection to the window server.

   593 

   594 - creates a connection to the file server so that the control environment can 

   595 access resource files

   596 

   597 - creates a screen device, the application's window group, a standard font, 

   598 and a graphics context (the system GC).

   599 

   600 The window group is constructed with the initial focus state aInitialFocusState, 

   601 which automatically takes keyboard focus when it is created. 

   602 

   603 @param aInitialFocusState Window group initial focus state. If ETrue, keyboard 

   604 focus is enabled, otherwise keyboard focus is disabled. 

   605 @param aDefaultScreenNumber The default screen number 

   606 @param aWindowGroupID The window group ID which will be set as the parent

   607 */

   608 EXPORT_C void CCoeEnv::ConstructL(TBool aInitialFocusState, TInt aDefaultScreenNumber, TInt aWindowGroupID )

   609 	{

   610 	if (iEnvFlags&EExtraPointerIsErrorCode)

   611 		{

   612 		User::LeaveIfError(REINTERPRET_CAST(TInt, iExtra));

   613 		}

   614 	iExtra=new(ELeave) CCoeEnvExtra;

   615 	iExtra->ConstructL();

   616 	iErrorText=new(ELeave) TBuf<KErrorTextLength>;

   617 	iErrorContextText=new(ELeave) TBuf<KErrorContextTextLength>;

   618 	CreateActiveSchedulerL();

   619 	CActiveScheduler::Add(this);

   620 	ConnectToFileServerL();

   621 	ConnectToWindowServerL();

   622 	InitScreenL( aDefaultScreenNumber); // Modified May 04 support for Multiple Screens.

   623 	InitRootWindowL(aInitialFocusState, aWindowGroupID);

   624 	InitSystemFontsL();

   625 	InitSystemGcL();

   626 	PopulateArrayOfScreenItemsL();

   627 	iExtra->iRedrawer=new(ELeave) CCoeRedrawer(iWsSession);

   628 	iExtra->iFepTracker=CCoeFepTracker::NewL(*this);

   629 	iExtra->iFepLoader=CCoeFepLoader::NewL(*this, iExtra->iFepLoader);

   630 	iExtra->iHighPriorityActive=CCoeEnvExtra::CHighPriorityActive::NewL(*iExtra);

   631 

   632 	iExtra->iDefaultFontProvider = CCoeFontProvider::NewL();

   633 	User::LeaveIfNull( iExtra->iDefaultTextDrawer = CCoePlainTextDrawer::New(KRgbBlack) );

   634 	iExtra->iDefaultTextDrawer->SetReusable( ETrue );

   635 	// iExtra->iAppStartupInstrumentationEventIdBase is set in SetAppStartupInstrumentationEventIdBaseL

   636 	RequestEventNotification();

   637 	}

   638 

   639 void CCoeEnv::CreateActiveSchedulerL()

   640 	{

   641 	CActiveScheduler::Install(new(ELeave) CCoeScheduler(this));

   642 	}

   643 

   644 void CCoeEnv::ConnectToFileServerL()

   645 	{

   646 	User::LeaveIfError(iFsSession.Connect());

   647 	}

   648 

   649 void CCoeEnv::ConnectToWindowServerL()

   650 	{

   651 	User::LeaveIfError(iWsSession.Connect(iFsSession));

   652 	}

   653 

   654 void CCoeEnv::InitScreenL( TInt aDefaultScreenNumber )

   655 	{

   656 	iScreen=new(ELeave) CWsScreenDevice(iWsSession);

   657 	User::LeaveIfError(iScreen->Construct( aDefaultScreenNumber ));

   658 	}

   659 

   660 void CCoeEnv::InitRootWindowL(TBool aInitialFocusState, TInt aWindowGroupID)

   661 	{

   662 	iRootWin=RWindowGroup(iWsSession);

   663 	if (aWindowGroupID)

   664 		{

   665 		User::LeaveIfError(iRootWin.ConstructChildApp(aWindowGroupID, (TUint32)this, aInitialFocusState));

   666 		}

   667 	else

   668 		{

   669 		User::LeaveIfError(iRootWin.Construct((TUint32)this, aInitialFocusState));

   670 		}

   671 	}

   672 

   673 EXPORT_C void CCoeEnv::InitSystemFontsL()

   674 // Hard-coded font is only used for test code

   675 /** Initialises the system fonts.

   676 

   677 This function is called by ConstructL() during the construction of a CCoeEnv. 

   678 The default implementation creates only the normal control environment font, 

   679 but this function may be overridden to create other fonts. */

   680 	{ 

   681 	TFontSpec spec(KSystemFont,200); // 10 points

   682 	iNormalFont=CreateScreenFontL(spec);

   683 	}

   684 

   685 void CCoeEnv::InitSystemGcL()

   686 	{

   687 	iSystemGc=CreateGcL();

   688 	}

   689 

   690 EXPORT_C CWindowGc* CCoeEnv::CreateGcL()

   691 /** Fully constructs a new graphics context.

   692 

   693 CCoeEnv calls this function during construction to create the system graphics 

   694 context, which can be accessed using SystemGc(). Hence the system graphics 

   695 context is always available.

   696 

   697 @return A new graphics context.

   698 @see SystemGc() */

   699 	{

   700 	CGraphicsContext* temp;

   701 	User::LeaveIfError(iScreen->CreateContext(temp));

   702 	return((CWindowGc*)temp);

   703 	}

   704 

   705 EXPORT_C CFbsFont* CCoeEnv::CreateDeviceFontL(CGraphicsDevice* aDevice,const TFontSpec& aFontSpec)

   706 /** Creates a font for the specified graphics device. 

   707 

   708 If you wish to use the default screen device as the graphics device, use 

   709 CreateScreenFontL()  instead of this function.

   710 

   711 This function calls GetNearestFontToMaxHeightInTwips() on the graphics device 

   712 given by aDevice, passing it the font defined by aFontSpec.

   713 

   714 All fonts created by this function should be released using 

   715 MGraphicsDeviceMap::ReleaseFont(), when they are no longer required.

   716 

   717 Note that the font will not be scaled automatically when the control's zoom factor 

   718 is changed using CCoeControl::SetZoomFactor(). This is also the case for NormalFont(), 

   719 CEikonEnv::LegendFont(), CEikonEnv::TitleFont(), CEikonEnv::AnnotationFont(), 

   720 CEikonEnv::DenseFont().

   721 

   722 To avoid this problem, and also make resource management much easier, it is highly 

   723 recommended to use CCoeControl::ScreenFont() instead.

   724 

   725 @see CCoeEnv::CreateScreenFontL()

   726 @see CCoeControl::ScreenFont()

   727 @see CCoeFontProvider

   728 

   729 @param aDevice The graphics device for which to create the font.

   730 @param aFontSpec The font specification.

   731 @return The new font. */

   732 	{

   733 	CFont* ret;

   734 	User::LeaveIfError(aDevice->GetNearestFontToMaxHeightInTwips(ret,aFontSpec,aFontSpec.iHeight));

   735 	return((CFbsFont*)ret);

   736 	}

   737 

   738 EXPORT_C CFbsFont* CCoeEnv::CreateScreenFontL(const TFontSpec& aFontSpec)

   739 /** Creates a font for the default graphics device, based on the specified TFontSpec. 

   740 

   741 All fonts created using this function should be released using ReleaseScreenFont() 

   742 when they are no longer required.

   743  

   744 Note that the font will not be scaled automatically when the zoom factor is changed 

   745 using CCoeControl::SetZoomFactor(). This is also the case for NormalFont(), 

   746 CEikonEnv::LegendFont(), CEikonEnv::TitleFont(), CEikonEnv::AnnotationFont(), 

   747 CEikonEnv::DenseFont().

   748 

   749 To avoid this problem, and also make resource management much easier, it is highly 

   750 recommended to use CCoeControl::ScreenFont() instead.

   751 

   752 @see CCoeControl::ScreenFont()

   753 @see CCoeFontProvider

   754 

   755 @param aFontSpec The font specification.

   756 @return The new font. */

   757 	{

   758 	return(CreateDeviceFontL(iScreen,aFontSpec));

   759 	}

   760 

   761 EXPORT_C void CCoeEnv::ReleaseScreenFont(CFont* aFont) const

   762 /** Frees all resources used by the font. 

   763 

   764 This function should be used to release a font when the font is no longer 

   765 required. Fonts are created using CreateScreenFontL().

   766 

   767 @param aFont The font to be released. */

   768 	{

   769 	if (aFont)

   770 		iScreen->ReleaseFont(aFont);

   771 	}

   772 

   773 EXPORT_C void CCoeEnv::Flush(TTimeIntervalMicroSeconds32 aDelay)

   774 /** Flushes the client-side window server buffer. 

   775 

   776 The function does this by first calling RWsSession::Flush(), and then User::After(aDelay), 

   777 which puts the current process in a sleep state for the time interval 

   778 given by aDelay.

   779 

   780 @param aDelay Delay for which to sleep the current process after flushing 

   781 the window server buffer. By default the delay is zero. */

   782 	{

   783 	iWsSession.Flush();

   784 	User::After(aDelay);

   785 	}

   786 

   787 EXPORT_C TBool CCoeEnv::IsWservEventPending() const

   788 /** Tests if there is a standard event waiting to be processed. 

   789 

   790 Note: standard events are all window server events except redraw and priority 

   791 key events.

   792 

   793 @return ETrue if a standard event is pending. EFalse if no standard event 

   794 is pending. */

   795 	{

   796 	return(iStatus.Int()!=KRequestPending);

   797 	}

   798 

   799 EXPORT_C TBool CCoeEnv::IsRedrawEventPending() const

   800 /** Tests if there is a redraw event waiting to be processed.

   801 

   802 @return ETrue if a redraw event is pending. EFalse if no redraw event is pending. */

   803 	{

   804 	return(iExtra->iRedrawer->iStatus.Int()!=KRequestPending);

   805 	}

   806 

   807 EXPORT_C void CCoeEnv::ReadResourceAsDes8(TDes8& aDes,TInt aResourceId) const

   808 /** Reads a resource into an 8 bit descriptor. 

   809 

   810 The descriptor must be long enough to contain the entire resource. No memory 

   811 is allocated by this function.

   812 

   813 If the read fails the function sets an error condition and performs any cleanup 

   814 required. The error condition causes the GUI to launch an alert window.

   815 Deprecated: use CCoeEnv::ReadResourceAsDes8L() instead.

   816 

   817 @deprecated

   818 @param aDes On return, contains the read resource.

   819 @param aResourceId The numeric ID of the resource to be read.

   820 @see RResourceFile::ReadL()

   821 @see KErrCoeFailedToReadFromProgDisk */

   822 	{

   823 	aDes.Zero();

   824 	RResourceFile& rf=ResourceFileForId(aResourceId);

   825 	TRAPD(err,rf.ReadL(aDes,aResourceId));

   826 	if (err==KErrNoMemory)

   827 		{

   828 		CBaActiveScheduler::DisplayExtendedError(KUidConeDll,KErrNoMemory);

   829 		}

   830  	else if (err!=KErrNone)

   831 		{

   832 		CBaActiveScheduler::DisplayExtendedError(KUidConeDll,KErrCoeFailedToReadFromProgDisk);

   833 		}

   834 	}

   835 

   836 EXPORT_C void CCoeEnv::ReadResourceAsDes8L(TDes8& aDes,TInt aResourceId) const

   837 /** Reads a resource into an 8 bit descriptor.

   838 

   839 The descriptor must be long enough to contain the entire resource. 

   840 The method leaves if an error occurs when reading from the resource file.

   841 

   842 @param aDes On return, contains the read resource.

   843 @param aResourceId The numeric ID of the resource to be read. */

   844 	{

   845 	RResourceFile& rf=ResourceFileForId(aResourceId);

   846 	rf.ReadL(aDes,aResourceId);

   847 	}

   848 

   849 EXPORT_C void CCoeEnv::ReadResourceAsDes16(TDes16& aDes,TInt aResourceId) const

   850 /** Reads a resource into a 16 bit descriptor. 

   851 

   852 The descriptor must be long enough to contain the entire resource. No memory 

   853 is allocated by this function.

   854 

   855 If the read fails the function sets an error condition and performs any cleanup 

   856 required. The error condition causes the GUI to launch an alert window.

   857 Deprecated: use CCoeEnv::ReadResourceAsDes16L() instead.

   858 

   859 @deprecated

   860 @param aDes On return, contains the read resource.

   861 @param aResourceId The numeric ID of the resource to be read.

   862 @see RResourceFile::ReadL()

   863 @see KErrCoeFailedToReadFromProgDisk */

   864 	{

   865 	aDes.Zero();

   866  // Reading Unicode string

   867 	RResourceFile& rf=ResourceFileForId(aResourceId);

   868 	TPtr8 readBuffer((TText8* ) aDes.Ptr(),aDes.MaxSize());

   869 	TRAPD(err,rf.ReadL(readBuffer,aResourceId));

   870 	__ASSERT_DEBUG((readBuffer.Length()%2)==0||(err==KErrNone),Panic(ECoePanicWrongResourceFormat));

   871 	aDes.SetLength((readBuffer.Length()+1)>>1);

   872 

   873 	if (err==KErrNoMemory)

   874 		{

   875 		CBaActiveScheduler::DisplayExtendedError(KUidConeDll,KErrNoMemory);

   876 		}

   877 	else if (err!=KErrNone)

   878 		{

   879 		CBaActiveScheduler::DisplayExtendedError(KUidConeDll,KErrCoeFailedToReadFromProgDisk);

   880 		}

   881 	}

   882 

   883 EXPORT_C void CCoeEnv::ReadResourceAsDes16L(TDes16& aDes,TInt aResourceId) const

   884 /** Reads a resource into a 16 bit descriptor.

   885 

   886 The descriptor must be long enough to contain the entire resource. 

   887 The method leaves if an error occurs when reading from the resource file.

   888 

   889 @param aDes On return, contains the read resource.

   890 @param aResourceId The numeric ID of the resource to be read. */

   891 	{

   892 	RResourceFile& rf=ResourceFileForId(aResourceId);

   893 	TPtr8 readBuffer((TText8* ) aDes.Ptr(),aDes.MaxSize());

   894 	rf.ReadL(readBuffer,aResourceId);

   895  	__ASSERT_DEBUG((readBuffer.Length()%2)==0,Panic(ECoePanicWrongResourceFormat));

   896 	aDes.SetLength((readBuffer.Length()+1)>>1);

   897 	}

   898 

   899 EXPORT_C HBufC8* CCoeEnv::AllocReadResourceAsDes8L(TInt aResourceId) const

   900 /** Reads a resource into an 8 bit heap buffer, allocating the buffer. 

   901 

   902 The calling program must destroy the heap descriptor when it is no longer 

   903 needed.

   904 

   905 @param aResourceId The numeric ID of the resource to be read.

   906 @return Pointer to a heap descriptor containing the resource data.

   907 @see RResourceFile::AllocReadL() */

   908 	{

   909 	RResourceFile& rf=ResourceFileForId(aResourceId);

   910 	return(rf.AllocReadL(aResourceId));

   911 	}

   912 

   913 EXPORT_C HBufC16* CCoeEnv::AllocReadResourceAsDes16L(TInt aResourceId) const

   914 /** Reads a resource into a 16 bit heap buffer, allocating the buffer. 

   915 

   916 The calling program must destroy the heap descriptor when it is no longer 

   917 needed.

   918 

   919 @param aResourceId The numeric ID of the resource to be read.

   920 @return Pointer to a heap descriptor containing the resource data. */

   921 	{

   922 	RResourceFile& rf=ResourceFileForId(aResourceId);

   923 	HBufC8* readBuffer=rf.AllocReadLC(aResourceId);

   924  	__ASSERT_DEBUG((readBuffer->Length()%2)==0,Panic(ECoePanicWrongResourceFormat));

   925 	const TPtrC16 ptrReadBuffer((TText16*) readBuffer->Ptr(),(readBuffer->Length()+1)>>1);

   926 	HBufC16* textBuffer=HBufC16::NewL(ptrReadBuffer.Length());

   927 	*textBuffer=ptrReadBuffer;

   928 	CleanupStack::PopAndDestroy();

   929 	return textBuffer;

   930 	}

   931 

   932 EXPORT_C HBufC8* CCoeEnv::AllocReadResourceAsDes8LC(TInt aResourceId) const

   933 /** Reads a resource into an 8 bit heap buffer, allocating the buffer and pushing 

   934 it onto the cleanup stack. 

   935 

   936 The calling program must destroy the heap descriptor when it is no longer 

   937 needed.

   938 

   939 @param aResourceId The numeric ID of the resource to be read.

   940 @return Pointer to a heap descriptor containing the resource data.

   941 @see RResourceFile::AllocReadL() */

   942 	{

   943 	RResourceFile& rf=ResourceFileForId(aResourceId);

   944 	return(rf.AllocReadLC(aResourceId));

   945 	}

   946 

   947 EXPORT_C HBufC16* CCoeEnv::AllocReadResourceAsDes16LC(TInt aResourceId) const

   948 /** Reads a resource into a 16 bit heap buffer, allocating the buffer and pushing 

   949 it onto the cleanup stack. 

   950 

   951 The calling program must destroy the heap descriptor when it is no longer 

   952 needed.

   953 

   954 @param aResourceId The numeric ID of the resource to be read.

   955 @return Pointer to a heap descriptor containing the resource data.

   956 @see RResourceFile::AllocReadL() */

   957 	{

   958  // Reading Unicode string

   959 	HBufC16* textBuffer=AllocReadResourceAsDes16L(aResourceId);

   960 	CleanupStack::PushL(textBuffer);

   961 	return textBuffer;

   962 	}

   963 

   964 EXPORT_C void CCoeEnv::CreateResourceReaderLC(TResourceReader& aReader,TInt aResourceId) const

   965 /** Reads a resource from a resource file and sets its resource reader. 

   966 

   967 The resource reader can subsequently be used to read resource data from the 

   968 resource. The resource reader is also placed on the cleanup stack.

   969 

   970 Note: the GUI framework passes a resource reader as an argument to 

   971 CCoeControl::ConstructFromResourceL(), with the resource reader's buffer already 

   972 set to contain the relevant resource for that control.

   973 

   974 @param aReader The resource reader.

   975 @param aResourceId The numeric ID of the resource to be read. */

   976 	{

   977 	RResourceFile& rf=ResourceFileForId(aResourceId);

   978 	HBufC8* resource=rf.AllocReadLC(aResourceId);

   979 	aReader.SetBuffer(resource);

   980 	}

   981 

   982 EXPORT_C TInt CCoeEnv::AddResourceFileL(const TDesC& aFileName)

   983 /** Adds the specified resource file to the list maintained by CCoeEnv. 

   984 

   985 Resource files are access counted so AddResourceFileL() can be called several 

   986 times for the same resource file. However, care should be taken to call DeleteResourceFile() 

   987 for each resource file added to the list.

   988 

   989 @param aFileName The resource file name.

   990 @return The offset value defined for this resource file.

   991 @panic CONE 15 The resource file has no NAME statement (i.e. has no offset).

   992 @see RResourceFile::Offset()

   993 @see ResourceFileVersionNumber() */

   994 	{

   995 	if (!iResourceFileArray)

   996 		iResourceFileArray=new(ELeave) CArrayFixFlat<RResourceFile>(2); // granularity of 2

   997 	RResourceFile resourceFile;

   998 	resourceFile.OpenL(iFsSession,aFileName);

   999 	CleanupClosePushL(resourceFile);

  1000 	resourceFile.ConfirmSignatureL(ResourceFileVersionNumber());

  1001 	TInt offset=resourceFile.Offset();

  1002 	if (!offset)

  1003 		Panic(ECoePanicResourceFileHasNullName);

  1004 	TInt count=iResourceFileArray->Count();

  1005 	while (count--)

  1006 		{

  1007 		TInt previousOffset=(*iResourceFileArray)[count].Offset();

  1008 		if (offset==previousOffset)

  1009 			break;

  1010 		}

  1011 	if (count>=0)

  1012 		{

  1013 		++iExtra->iResFileAccessCount[count];

  1014 		resourceFile.Close();

  1015 		}

  1016 	else

  1017 		{

  1018 		iResourceFileArray->AppendL(resourceFile);

  1019 		const TInt error=iExtra->iResFileAccessCount.Append(1);

  1020 		if (error!=KErrNone)

  1021 			{

  1022 			iResourceFileArray->Delete(iResourceFileArray->Count()-1);

  1023 			User::Leave(error);

  1024 			}

  1025 		}

  1026 	CleanupStack::Pop(); // resourceFile

  1027 	return(offset);

  1028 	}

  1029 

  1030 EXPORT_C void CCoeEnv::DeleteResourceFile(TInt aOffset)

  1031 /** Deletes the specified resource file from the list maintained by CCoeEnv.

  1032 

  1033 @param aOffset The offset value defined for the resource file to delete.

  1034 @panic CONE 13 The specified resource file does not exist in the list. */

  1035 	{

  1036 	if (!aOffset)

  1037 		return;

  1038 	TInt count=iResourceFileArray->Count();

  1039 	while (count--)

  1040 		{

  1041 		RResourceFile& data=(*iResourceFileArray)[count];

  1042 		if (data.Offset()==aOffset)

  1043 			{

  1044 			if (--iExtra->iResFileAccessCount[count]==0)

  1045 				{

  1046 				data.Close();

  1047 				iResourceFileArray->Delete(count);

  1048 				iExtra->iResFileAccessCount.Remove(count);

  1049 				}

  1050 			return;

  1051 			}

  1052 		}

  1053 	Panic(ECoePanicUnknownResourceFile);

  1054 	}

  1055 

  1056 RResourceFile& CCoeEnv::ResourceFileForId(TInt aResourceId) const

  1057 	{

  1058 	RResourceFile* resourceptr=NULL;

  1059 	TRAPD(err, resourceptr=DoResourceFileForIdL(aResourceId));

  1060 	if(err!=KErrNone)

  1061 	    {

  1062 	    Panic(ECoePanicNoResourceFileForId);

  1063 	    }

  1064 	return *resourceptr;

  1065 	}

  1066 

  1067 RResourceFile* CCoeEnv::DoResourceFileForIdL(TInt aResourceId) const

  1068     {

  1069     TInt count=iResourceFileArray->Count();

  1070     FOREVER

  1071         {

  1072         if (!count--)

  1073             Panic(ECoePanicNoResourceFileForId);

  1074         RResourceFile& resourceFile=(*iResourceFileArray)[count];

  1075         if (resourceFile.OwnsResourceIdL(aResourceId))

  1076             return &resourceFile;

  1077         }

  1078     }

  1079 

  1080 

  1081 void CCoeEnv::DestroyAllResourceFiles()

  1082 	{

  1083 	if (!iResourceFileArray)

  1084 		return;

  1085 	TInt count=iResourceFileArray->Count();

  1086 	while (count--)

  1087 		{

  1088 		RResourceFile& resourceFile=(*iResourceFileArray)[count];

  1089 		resourceFile.Close();

  1090 		}

  1091 	delete(iResourceFileArray);

  1092 	}

  1093 

  1094 EXPORT_C CDesC8ArrayFlat* CCoeEnv::ReadDesC8ArrayResourceL(TInt aResourceId)

  1095 /** Reads a resource into an 8 bit descriptor array.

  1096 

  1097 @param aResourceId The numeric ID of the resource to be read.

  1098 @return A pointer to the descriptor array containing the resource data.

  1099 @see TResourceReader::ReadDesC8ArrayL() */

  1100 	{

  1101 	TResourceReader reader;

  1102 	CreateResourceReaderLC(reader,aResourceId);

  1103 	CDesC8ArrayFlat* array=reader.ReadDesC8ArrayL();

  1104 	CleanupStack::PopAndDestroy();

  1105 	return(array);

  1106 	}

  1107 

  1108 EXPORT_C CDesC16ArrayFlat* CCoeEnv::ReadDesC16ArrayResourceL(TInt aResourceId)

  1109 /** Reads a resource into a 16 bit descriptor array. 

  1110 

  1111 Ownership of the array is transferred to the caller.

  1112 

  1113 @param aResourceId The numeric ID of the resource to be read.

  1114 @return A pointer to the descriptor array containing the resource data.

  1115 @see TResourceReader::ReadDesC16ArrayL() */

  1116 	{

  1117 	// Reading array of Unicode descriptors

  1118 	TResourceReader reader;

  1119 	CreateResourceReaderLC(reader,aResourceId);

  1120 	CDesC16ArrayFlat* array=reader.ReadDesC16ArrayL();

  1121 	CleanupStack::PopAndDestroy();

  1122 	return(array);

  1123 	}

  1124 

  1125 EXPORT_C void CCoeEnv::Format128(TDes& aDes,TInt aResourceId,...)

  1126 /** Reads a 128 byte resource into a formatted string.

  1127 

  1128 The format of the string is given by the variable argument list. 

  1129 The unformatted resource data must not be longer than 128 bytes.

  1130 If it is, you should use Format256() instead.

  1131 

  1132 @param aDes On return, contains the formatted resource data.

  1133 @param aResourceId The numeric ID of the resource to be read.

  1134 @param ... Formatting information. */