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

//

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <apaidpartner.h>

#include <vwsdefpartner.h>

#endif

#include <coeaui.h>

#include <coecntrl.h>

#include "coepanic.h"

#include <coemain.h>

#include <apgtask.h>

#include "COETLS.H"

#include "COEVWMAN.H"

#define STRICT_INNER_AND_OUTER_CHECKING

const TInt KAppUiControlStackGroupId=0;

//

// class CCoeControlStack

//

struct SStackedControl

	{

	CCoeControl* iControl;

	TInt iPriority;

	TInt iFlags;

	TInt iGroupId;

	};

class CCoeControlStack : public CArrayFixFlat<SStackedControl>

	{

public:

	inline CCoeControlStack() : CArrayFixFlat<SStackedControl>(2) { } // granularity of two

	TKeyResponse OfferKeyL(const TKeyEvent& aKeyEvent,TEventCode aType);

	inline void SetCurrentGroupId(TInt aGroupId) { iCurrentGroupId=aGroupId; };

	TBool IsGroupIdCurrent(TInt aGroupId) const;

public:

	TInt iKeyIndex;

	TInt iCurrentGroupId;

	};

TBool CCoeControlStack::IsGroupIdCurrent(TInt aGroupId) const

	{

	return (aGroupId==KAppUiControlStackGroupId || aGroupId==iCurrentGroupId);

	}

TKeyResponse CCoeControlStack::OfferKeyL(const TKeyEvent& aKeyEvent,TEventCode aType)

	{

	iKeyIndex=0;

	while (iKeyIndex<Count())

		{ // both iKeyIndex and Count() can be changed inside OfferKeyEventL call below

		SStackedControl& stacked=(*this)[iKeyIndex++];

		if (stacked.iFlags&ECoeStackFlagRefusesAllKeys)

			continue;

		if ( !IsGroupIdCurrent(stacked.iGroupId) )

			continue;

		const TInt oldKeyIndex=iKeyIndex;

		const TInt oldCount=Count();

		const TKeyResponse keyResponse=stacked.iControl->OfferKeyEventL(aKeyEvent,aType);

		if (Count()==oldCount)

			iKeyIndex=oldKeyIndex; // doing this means that CCoeControl::OfferKeyEventL implementations can be nested inside one another (which would happen if a control calls CCoeEnv::SimulateKeyEventL from it's OfferKeyEventL)

		if (keyResponse==EKeyWasConsumed)

			return(EKeyWasConsumed);

		}

	return(EKeyWasNotConsumed);

	}

//

// CCoeAppUi::CExtra class definition

//

class CCoeAppUi::CExtra : public CBase

	{

public:

	CCoeAppUi* iOuter; // this pointer does not own anything

	CCoeAppUi* iInner; // this pointer does not own anything

	};

//

// CCoeAppUi class definitions

//

/** C++ constructor. 

To complete construction, call ConstructL(). */

EXPORT_C CCoeAppUi::CCoeAppUi()

	{

	iCoeEnv=TheCoe();

	}

/** The destructor frees all resources owned by the object, 

including the control stack and the view server session. */

EXPORT_C CCoeAppUi::~CCoeAppUi()

	{

	if (iStack)

 		{

		TInt pos=0;

		const TInt count=iStack->Count();

		CCoeControlStack* stack=iStack;

		iStack=NULL;

		while (pos<count)

			{

			SStackedControl& stacked=(*stack)[pos++];

			if (stacked.iFlags&ECoeStackFlagOwnershipTransfered)

				{

				if (iExtra!=NULL)

					{

#if defined(STRICT_INNER_AND_OUTER_CHECKING)

					// we do not need to remove stacked.iControl from outer appUI-s as controls owned by an appUI (which, by this stage, we know is true of stacked.iControl) are *not* propagated to outer appUIs by AddToStackL

					__ASSERT_ALWAYS(iExtra->iInner==NULL, Panic(ECoePanicInnerAppUiNotNull1));

#else

					CCoeAppUi* appUi;

					for (appUi=iExtra->iOuter; appUi!=NULL; appUi=appUi->iExtra->iOuter)

						{

						appUi->DoRemoveFromStack(appUi->iStack,stacked.iControl,ERemoveOnlyIfSharable);

						}

					for (appUi=iExtra->iInner; appUi!=NULL; appUi=appUi->iExtra->iInner)

						{

						appUi->DoRemoveFromStack(appUi->iStack,stacked.iControl,ERemoveOnlyIfSharable);

						}

#endif

					}

				delete(stacked.iControl);

				}

			}

		delete(stack);

		}

	if (iExtra!=NULL)

		{

		CCoeAppUi* outer=iExtra->iOuter;

		CCoeAppUi* inner=iExtra->iInner;

		if (outer!=NULL)

			{

			outer->iExtra->iInner=inner;

			}

#if defined(STRICT_INNER_AND_OUTER_CHECKING)

		__ASSERT_ALWAYS(inner==NULL, Panic(ECoePanicInnerAppUiNotNull2));

#else

		if (inner!=NULL)

			{

			inner->iExtra->iOuter=outer;

			}

#endif

		}

	delete iViewManager;

	delete iExtra;

	}

/** Completes construction of the CCoeAppUi object.

It creates the application's control stack and starts a view server session.

@param aPrevious If non-NULL, ConstructL() transfers ownership of all of the 

controls owned by aPrevious to the new app UI being constructed, adding them 

to the new app UI's control stack. */

EXPORT_C void CCoeAppUi::ConstructL(CCoeAppUi* aPrevious)

	{

	iStack=new(ELeave) CCoeControlStack;

	iViewManager=CCoeViewManager::NewL(*iCoeEnv,*this,aPrevious);

	iExtra=new(ELeave) CExtra;

	iExtra->iOuter=aPrevious;

	if (!aPrevious)

		return;

	aPrevious->iExtra->iInner=this;

	CCoeControlStack* previousStack=aPrevious->iStack;

	TInt pos=0;

	const TInt count=previousStack->Count();

	while (pos<count)

		{

		SStackedControl stacked=(*previousStack)[pos++];

		if (!(stacked.iFlags&ECoeStackFlagSharable))

			continue;

		stacked.iFlags&=(~ECoeStackFlagOwnershipTransfered);

		iStack->AppendL(stacked);

		}

	}

/** Handles events sent to the application by the window server. 

This function is called whenever the window server sends key or pointer events 

or some other special events to the application. It calls one of a number of 

functions, according to the type of event.

For key events, it calls CCoeControl::OfferKeyEventL() for each control 

on the control stack, beginning with the control at the top (position 0) until 

a control consumes it. If no control on the stack consumes the key event, the app UI's  

HandleKeyEventL() is called. Note that CCoeControl::OfferKeyEventL() is not 

called for controls whose ECoeStackFlagRefusesAllKeys flag is set.

For pointer events, CCoeControl::ProcessPointerEventL() is called 

on the control specified in aDestination.

For pointer buffer ready events, ProcessPointerBufferReadyL() is called 

on the control specified in aDestination.

For other events, for instance focus change events, this function 

calls one of the following CCoeAppUi private virtual functions: 

- HandleForegroundEventL()

- HandleSwitchOnEventL()

- HandleSystemEventL()

- HandleScreenDeviceChangedL()

- HandleApplicationSpecificEventL(). 

All these functions have empty implementations in this class, and are implemented by 

derived classes, if required.

@param aEvent A window server event.

@param aDestination The control associated with the event. This is only relevant 

for pointer events.

@see CCoeAppUi::HandleWsEventL() */

EXPORT_C void CCoeAppUi::HandleWsEventL(const TWsEvent& aEvent,CCoeControl* aDestination)

	{

	TInt type=aEvent.Type();

	switch (type)

		{

	case EEventKey:

	case EEventKeyUp:

	case EEventKeyDown:

		if (iStack->OfferKeyL(*aEvent.Key(),(TEventCode)type)==EKeyWasNotConsumed)

			HandleKeyEventL(*aEvent.Key(),(TEventCode)type);

		break;

	case EEventPointer:

		aDestination->ProcessPointerEventL(*aEvent.Pointer());

		break;

	case EEventPointerBufferReady:

		aDestination->ProcessPointerBufferReadyL();

		break;

	case EEventFocusLost:

	case EEventFocusGained:

		{

		TBool foreground=(type==EEventFocusGained);

		if (foreground)

			{

			iCoeEnv->NotifyForegroundObserversOfGainingForeground();

			}

		else

			{

			iCoeEnv->NotifyForegroundObserversOfLosingForeground();

			}

		CCoeControl* topFocusable=TopFocusableControl();

		HandleForegroundEventL(foreground);

		if (!topFocusable)

			SetAndDrawFocus(foreground);

		else if(IsControlOnStack(topFocusable))

			{

			TBool isFocused=topFocusable->IsFocused();

			if ((foreground && !isFocused) || (!foreground && isFocused))

				topFocusable->SetFocus(foreground,EDrawNow);

			}

		break;

		}

	case EEventSwitchOn:

		HandleSwitchOnEventL(aDestination);

		break;

	case EEventUser:

		{

		TApaSystemEvent data(*(TApaSystemEvent*)(aEvent.EventData()));

		// EApaSystemEventSecureShutdown must be sent with event-type EEventPowerMgmt to be valid

		if(data<KApaSystemEventsWithPowerMgmtCapabilityStart || data>KApaSystemEventsWithPowerMgmtCapabilityEnd)

			HandleSystemEventL(aEvent);

		break;

		}

	case EEventPowerMgmt:

		HandleSystemEventL(aEvent);

		break;

	case EEventMessageReady:

		{

		TUid messageUid;

		TPtr8 messageParameters(NULL, 0, 0);

		iCoeEnv->GetMessageNotifyingObserversLC(aEvent.Handle(), messageUid, messageParameters, aEvent);

		CleanupStack::PopAndDestroy(); // stuff left on cleanup-stack by GetMessageNotifyingObserversLC

		}

		break;

	case EEventScreenDeviceChanged:

		HandleScreenDeviceChangedL();

		break;

	default:

		if (type>EEventUser)

			{

			HandleApplicationSpecificEventL(type,aEvent);

			iCoeEnv->NotifyResourceObserversOfChangeInResource();

			}

		break;

		}

	}

/**Monitor function for passing all windows events to registered monitor observers for optional inspection

@param aEvent The windows server event that has occured

*/

void CCoeAppUi::MonitorWsEvent(const TWsEvent& aEvent)

	{

	iCoeEnv->NotifyMessageMonitorObserversOfEvent(aEvent);

	}

/** Handles key events. 

This function is called by HandleWsEventL() if a key event occurred but 

none of the controls in the app UI's control stack consumed it.

Key events are sent to the application by the window server. A key press generates 

three separate key events in the order EEventKeyDown, EEventKey, and EEventKeyUp. 

Controls and app UIs are usually only interested in EEventKey events. 

This default implementation simply returns EKeyWasNotConsumed. It may need to be 

overridden if the derived app UI needs to handle certain key events itself. For 

example, in some applications, arrow keys may be used to navigate between views. 

In this case, the app UI should override this function to consume the arrow keys.

@param aKeyEvent The key event details, including the key code and any modifiers.

@param aType The type of key event, for instance standard, key up or key down.

@return This indicates whether or not the key event was consumed by the app UI. 

@publishedAll 

@released */

EXPORT_C TKeyResponse CCoeAppUi::HandleKeyEventL(const TKeyEvent& /*aKeyEvent*/,TEventCode /*aType*/)

	{

	return EKeyWasNotConsumed;

	}

/** Handles changes in keyboard focus when the application is brought to the 

foreground, or put into the background.

This function is called from HandleWsEventL() when an EEventFocusLost or 

EEventFocusGained event occurs.

This default implementation is empty.

@param aForeground ETrue if the application is being brought to the 

foreground, EFalse if it is being put into the background. */

EXPORT_C void CCoeAppUi::HandleForegroundEventL(TBool /*aForeground*/)

	{

	}

/** Handles the special switch on event.

This function is called by HandleWsEventL() if the device is switched on. 

This default implementation is empty.

@param aDestination The control associated with the event. */

EXPORT_C void CCoeAppUi::HandleSwitchOnEventL(CCoeControl* /*aDestination*/)

	{

	}

/** Handles system events generated by the window server.

This method should be overridden by the UI layer like @c CEikAppUi but not by individual applications. 

Application events (has a positive value greater than EEventUser) will be sent to 

@c HandleApplicationSpecificEventL.

Unrecognized events should be forwarded to the base class.

@param aEvent The window server event that occurred. */

EXPORT_C void CCoeAppUi::HandleSystemEventL(const TWsEvent& /*aEvent*/)

	{

	}

/** Handles an application-specific event.

This function is called from HandleWsEventL() when the app UI receives a window 

server event that is not in the standard range (in other words, it has a positive value 

greater than EEventUser). 

This default implementation is empty.

@param aType The application-specific event value, greater than EEventUser.

@param aEvent The window server event that occurred. */

EXPORT_C void CCoeAppUi::HandleApplicationSpecificEventL(TInt /*aType*/,const TWsEvent& /*aEvent*/)

	{

	}

/** Handles a change to the application's run-time resources for all controls on 

the app UI's control stack.

These are resources which are shared across the environment, such as colours, fonts or ZoomFactor.

@param aType Specifies a resource type. */

EXPORT_C void CCoeAppUi::HandleStackedControlsResourceChange(TInt aType)

	{

	TInt count=iStack->Count();

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

		{

		CCoeControl* control = (*iStack)[i].iControl;

		if (control && control->DrawableWindow())

			{

			if(aType == KUidValueCoeZoomChangeEvent)

				{

				TRAP_IGNORE(control->SetZoomFactorL(iCoeEnv->ZoomFactor().ZoomFactor()));//this method calls CCoeControl::HandleResourceChange()

				}

			else

				{

				control->HandleResourceChange(aType);	

				}

			}

		// There is a possibility that HandleResourceChange modifies the 

		// number of controls on the stack (by adding or removing controls)

		TInt newCount = iStack->Count();

		if (newCount != count)

			{

			// We must make sure that we update i to ensure that we don't skip

			// any control on the stack

			// 1) If controls have been added then we assume that they already use the correct resources

			//    so there isn't any need to update i no matter at which position they have been inserted

			//    (there is a risk we update them unnecessarily but this shouldn't be a problem)

			// 2) If controls have been removed we need to update i because they could have been removed 

			//    at a position <= i in which case we would skip a few controls if we didn't update i

			//    (as before there is a risk we update some controls twice if the removed controls were

			//    at a position > i).

			i = Max(-1, i + Min(0, newCount - count));   

			count = newCount;

			}

		}

	}

//

// Returns ETrue if aControl is present on this appUi's control stack

//

TBool CCoeAppUi::IsControlOnStack(CCoeControl* aControl) const

	{

	const TInt pos=(iStack? FindPos(iStack,aControl) : KErrNotFound);

	return (pos!=KErrNotFound);

	}

//

// Sets the current control stack group id to aGroupId. Only if a stacked control is part of the 

// current group does it play a part in the normal operation of the control stack.

//

// @since App-Framework_6.1

//

void CCoeAppUi::SetCurrentControlStackGroupId(TInt aGroupId)

	{

	iStack->SetCurrentGroupId(aGroupId);

	}

void CCoeAppUi::NotifyFontChange(const CCoeFontProvider& aFontProvider) 

    { 

    const CCoeFontProvider* fontProvider = &aFontProvider; 

    if(fontProvider == &iCoeEnv->DefaultFontProvider()) 

            fontProvider = NULL; 

    const TInt count = iStack->Count(); 

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

        { 

        CCoeControl* control = (*iStack)[i].iControl; 

        if (control && control->DrawableWindow()) 

            { 

            control->HandleResourceChange(KUidValueCoeFontChangeEvent); 

            control->NotifyFontChange(fontProvider); 

            } 

        } 

    } 

/** Notify all CCoeFontProvider's that the global logical-to-pixel mapping has changed in 

	CCoeControlStaticSettings

	@internalTechnology

*/

void CCoeAppUi::RefetchPixelMappingL()

	{

	const TInt count = iStack->Count(); 

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

        { 

        CCoeControl* control = (*iStack)[i].iControl; 

        if (control && control->DrawableWindow()) 

            { 

            control->RefetchPixelMappingL(); 

            control->HandleResourceChange(KUidValueCoeFontChangeEvent);

    		control->RequestRelayout(NULL);

            } 

        } 	

	}

/** Returns a list of help contexts appropriate to the current state of the application.

The array is generated from the help contexts for all visible controls on the app UI's 

control stack, and from the app UI itself (via CCoeAppUi::HelpContextL()).

@return A list of pointers to relevant help contexts. */

EXPORT_C CArrayFix<TCoeHelpContext>* CCoeAppUi::AppHelpContextL() const

	{

	CArrayFix<TCoeHelpContext>* contexts=new(ELeave) CArrayFixFlat<TCoeHelpContext>(1);

	CleanupStack::PushL(contexts);

	// walk the control stack for active contexts

	TInt count=iStack->Count();

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

		{

		SStackedControl stacked=(*iStack)[ii];

		if ( !(iStack->IsGroupIdCurrent(stacked.iGroupId)) )

			continue;

		CCoeControl* ctrl=stacked.iControl;

		if (ctrl->IsVisible())

			{

			TCoeHelpContext help;

			ctrl->GetHelpContext(help);

			if (!help.IsNull())

				contexts->AppendL(help);

			}

		}

	// ...then get any from the appui

	CArrayFix<TCoeHelpContext>* appContexts=HelpContextL();

	if (appContexts)

		{

		CleanupStack::PushL(appContexts);

		count=appContexts->Count();

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