/*

* Copyright (c) 2002-2010 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 FILES

#include <eikbtgpc.h>

#include <avkon.rsg>

#include <avkon.hrh>

#include <eikenv.h>

#include <eikmenub.h>

#include <eikcolib.h>

#include <eikapp.h>

#include <aknclearer.h>

#include <AknUtils.h>

#include <akntoolbar.h>

#include <akntranseffect.h>

#include <centralrepository.h>

#include "aknview.h"

#include "aknshut.h"

#include "aknenv.h"

#include "AknPanic.h"

#ifdef RD_SPLIT_VIEW

#include "AknViewNavigator.h"

#include <aknsutils.h>

#include <aknsdrawutils.h>

#include <AknLayoutScalable_Avkon.cdl.h>

#include <LayoutMetaData.cdl.h>

#endif // RD_SPLIT_VIEW

#include "aknViewAppUi.h"

// CONSTANTS

const TInt KAknAppUiViewsGranularity = 1;

const TInt KAknViewAsyncPriority = EActivePriorityRedrawEvents + 10;

#ifdef RD_SPLIT_VIEW

const TInt KAknSplitViewSize = 2;

// MODULE DATA STRUCTURES

enum TAknViewAppUiFlags

    {

    EAknViewAppUiButton1DownInRight = 0x00000001,

    EAknViewAppUiButton1DownInLeft  = 0x00000002,

    EAknViewAppUiFromSplitToSingle  = 0x00000004,

    EAknViewAppUiFromSingleToSplit  = 0x00000008,

    };

#endif // RD_SPLIT_VIEW

/**

*  CAknViewAppUi extension class.

*

*  @lib avkon.lib

*/

NONSHARABLE_CLASS(CAknViewAppUiExtension) : public CBase

    {

    public:

		/**

		* Two-phased constructor.

		*/

        static CAknViewAppUiExtension* NewL();

        /**

        * Destructor.

        */

        ~CAknViewAppUiExtension();

    private:

		/**

		* C++ constructor.

		*/

        CAknViewAppUiExtension();

		/**

		* Symbian 2nd-stage constructor.

		*/

        void ConstructL();

    public:

        RPointerArray<CAknView> iActiveViews;

#ifdef RD_SPLIT_VIEW

        RArray<CAknViewAppUi::TAknSplitViewContainer> iSplitViews;

        CAknViewNavigator* iNavigator;

        TInt iFlags;

#endif // RD_SPLIT_VIEW

        TBool iUseDefaultScreenClearer;

    };

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CAknViewAppUiExtension::CAknViewAppUiExtension

// C++ constructor.

// -----------------------------------------------------------------------------

//

CAknViewAppUiExtension::CAknViewAppUiExtension()

    {

    iUseDefaultScreenClearer = ETrue; // by default clear the screen automatically

    }

// -----------------------------------------------------------------------------

// CAknViewAppUiExtension::~CAknViewAppUiExtension

// Destructor.

// -----------------------------------------------------------------------------

//

CAknViewAppUiExtension::~CAknViewAppUiExtension()

    {

    iActiveViews.Close();

#ifdef RD_SPLIT_VIEW

    delete iNavigator;

    iSplitViews.Close();

#endif // RD_SPLIT_VIEW

    }

// -----------------------------------------------------------------------------

// CAknViewAppUiExtension::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CAknViewAppUiExtension* CAknViewAppUiExtension::NewL()

    {

    CAknViewAppUiExtension* ext = new ( ELeave ) CAknViewAppUiExtension;

    CleanupStack::PushL( ext );

    ext->ConstructL();

    CleanupStack::Pop();

    return ext;

    }

// -----------------------------------------------------------------------------

// CAknViewAppUiExtension::NewL

// Symbian 2nd-stage constructor.

// -----------------------------------------------------------------------------

//

void CAknViewAppUiExtension::ConstructL()

    {

    }

// -----------------------------------------------------------------------------

// CAknViewAppUi::TAknSplitViewContainer::IsPartOf

// Tests if a given view is part of the split view.

// -----------------------------------------------------------------------------

//

#ifdef RD_SPLIT_VIEW

TBool CAknViewAppUi::TAknSplitViewContainer::IsPartOf( const TUid aViewId )

    {

    if ( aViewId == iViewIds[0] || aViewId == iViewIds[1] )

        {

        return ETrue;

        }

    return EFalse;

    }

#endif // RD_SPLIT_VIEW

// -----------------------------------------------------------------------------

// CAknViewAppUi::CViewActivationItem::NewLC

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CAknViewAppUi::CViewActivationItem* CAknViewAppUi::CViewActivationItem::NewLC( CAknView* aNewView, TUid aCustomMessageId, const TDesC8& aCustomMessage, const TVwsViewId& aPrevViewId )

	{

	CViewActivationItem* self = new ( ELeave ) CViewActivationItem( aNewView, aCustomMessageId, aPrevViewId );

	CleanupStack::PushL( self );

	self->ConstructL( aCustomMessage );

	return self;

	}

// -----------------------------------------------------------------------------

// CAknViewAppUi::CViewActivationItem::~CViewActivationItem

// Destructor.

// -----------------------------------------------------------------------------

//

CAknViewAppUi::CViewActivationItem::~CViewActivationItem()

	{

	delete iCustomMessage;

	}

// -----------------------------------------------------------------------------

// CAknViewAppUi::CViewActivationItem::CViewActivationItem

// C++ default constructor.

// -----------------------------------------------------------------------------

//

CAknViewAppUi::CViewActivationItem::CViewActivationItem( CAknView* aNewView, TUid aCustomMessageId, const TVwsViewId& aPrevViewId )

: iNewView( aNewView ), iCustomMessageId( aCustomMessageId ), iPrevViewId( aPrevViewId )

	{

	}

// -----------------------------------------------------------------------------

// CAknViewAppUi::CViewActivationItem::ConstructL

// Symbian 2nd phase constructor.

// -----------------------------------------------------------------------------

//

void CAknViewAppUi::CViewActivationItem::ConstructL( const TDesC8& aCustomMessage )

	{

	iCustomMessage = aCustomMessage.AllocL();

	}

// -----------------------------------------------------------------------------

// CAknViewAppUi::BaseConstructL

// Second-phase base class constructor.

// -----------------------------------------------------------------------------

//

EXPORT_C void CAknViewAppUi::BaseConstructL( TInt aAppUiFlags )

	{

	CAknAppUi::BaseConstructL( aAppUiFlags );

	iViews = new ( ELeave ) CAknViews( KAknAppUiViewsGranularity );

	iActivationQueue = new ( ELeave ) CAknViewActivationQueue( KAknAppUiViewsGranularity );

	iActivationTick = CIdle::NewL( KAknViewAsyncPriority );

	iShutter = CAknViewShutter::NewL( *iEikonEnv, this );

	// Might be already constructed

    if ( !iExtension )

        {

        iExtension = CAknViewAppUiExtension::NewL();

        }

#ifdef RD_SPLIT_VIEW

	iExtension->iNavigator = new ( ELeave ) CAknViewNavigator( this );

	AddToStackL( iExtension->iNavigator, ECoeStackPriorityDefault - 1, ECoeStackFlagRefusesFocus );

#endif // RD_SPLIT_VIEW

	// Only clear the window for foreground apps.

	if ( iEikonEnv->RootWin().OrdinalPosition() == 0 &&

	     iExtension->iUseDefaultScreenClearer )

        {

	    if ( !iEikonEnv->StartedAsServerApp() )

            {

            iClearer = CAknLocalScreenClearer::NewL( ETrue );

            }

        else

            {

            iClearer = CAknLocalScreenClearer::NewL( ETrue, ETrue );

            }

        }

	}

// -----------------------------------------------------------------------------

// CAknViewAppUi::~CAknViewAppUi

// Destructor.

// -----------------------------------------------------------------------------

//

EXPORT_C CAknViewAppUi::~CAknViewAppUi()

	{

#ifdef RD_SPLIT_VIEW

	if (iExtension && iExtension->iNavigator )

	    RemoveFromStack( iExtension->iNavigator );

#endif // RD_SPLIT_VIEW

	delete iClearer;

	delete iShutter;

	delete iActivationTick;

	if ( iActivationQueue )

		{

		iActivationQueue->ResetAndDestroy();

		delete iActivationQueue;

		}

	if (iExtension)

	    for ( TInt i = 0; i < iExtension->iActiveViews.Count(); i++ )

	        {

    		iExtension->iActiveViews[i]->AknViewDeactivated();

	        }

	if ( iViews )

		{

		TInt count( iViews->Count() );

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

			{

			CCoeAppUi::DeregisterView( *iViews->At( i ) );

			}

		iViews->ResetAndDestroy();

		}

	delete iViews;

	delete iExtension;

	}

// -----------------------------------------------------------------------------

// CAknViewAppUi::AddViewL

// Registers a new view to the view server.

// -----------------------------------------------------------------------------

//

EXPORT_C void CAknViewAppUi::AddViewL( CAknView* aView )

	{

	// this is here to assert that BaseConstructL has been called properly.

	Extension();

	CCoeAppUi::RegisterViewL( *aView );

	iViews->AppendL( aView );

	}

// -----------------------------------------------------------------------------

// CAknViewAppUi::RemoveView

// Deregisters a new view from the view server.

// -----------------------------------------------------------------------------

//

EXPORT_C void CAknViewAppUi::RemoveView( TUid aViewId )

	{

	const TInt count( iViews->Count() );

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

		{

		}

	}

// -----------------------------------------------------------------------------

// CAknViewAppUi::View

// Returns a view that has the given UID.

// -----------------------------------------------------------------------------

//

EXPORT_C CAknView* CAknViewAppUi::View( TUid aView ) const

	{

	if ( iViews )

	    {

    	const TInt count( iViews->Count() );

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

	    	{

    		CAknView* view( iViews->At( i ) );

	    	if ( view->Id() == aView )

		        {

			    return view;

    		    }

    		}

	    }

	return NULL;

	}

// -----------------------------------------------------------------------------

// CAknViewAppUi::ProcessCommandL

// Processes a command.

// -----------------------------------------------------------------------------

//

EXPORT_C void CAknViewAppUi::ProcessCommandL( TInt aCommand )

	{

	MEikAppUiFactory* appUiFactory( iEikonEnv->AppUiFactory() );

	ASSERT( appUiFactory );

	if ( appUiFactory->Popup() )

	    {

	    ClosePopup();

	    }

    else if ( iView && iView->MenuBar() )

        {

        iView->MenuBar()->StopDisplayingMenuBar();

        }

    else if ( appUiFactory->MenuBar() )

        {

        StopDisplayingMenuBar();

        }

	if ( aCommand == EAknSoftkeyOptions )

		{

		if ( iView && iView->MenuBar() )

		    {

			iView->MenuBar()->TryDisplayMenuBarL();

		    }

		else if ( appUiFactory->MenuBar() )

		    {

			appUiFactory->MenuBar()->TryDisplayMenuBarL();

		    }

		return;

		}

	if ( aCommand == EAknSoftkeyContextOptions )

		{

		if ( iView && iView->MenuBar() )

		    {

			iView->MenuBar()->TryDisplayContextMenuBarL();

		    }

		else if ( appUiFactory->MenuBar() )

		    {

			appUiFactory->MenuBar()->TryDisplayContextMenuBarL();

		    }

		return;

		}

	if ( aCommand == EAknCmdExit )

		{

		CAknEnv::RunAppShutter();

		return;

		}

 	if ( iView )

 	    {

		iView->ProcessCommandL( aCommand );

 	    }

	if ( aCommand != EEikCmdCanceled )

	    {

	    HandleCommandL( aCommand );

	    }

	}

// -----------------------------------------------------------------------------

// CAknViewAppUi::ActivateLocalViewL

// Activates a local view.

// -----------------------------------------------------------------------------

//

EXPORT_C void CAknViewAppUi::ActivateLocalViewL( TUid aViewId )

	{

#ifdef RD_SPLIT_VIEW

    ActivateLocalViewL( aViewId, KNullUid, KNullDesC8 );

#else

	ActivateViewL( TVwsViewId( Application()->AppDllUid(), aViewId ) );

#endif // RD_SPLIT_VIEW	    

	}

// -----------------------------------------------------------------------------

// CAknViewAppUi::ActivateLocalViewL

// Activates a local view.

// -----------------------------------------------------------------------------

//

EXPORT_C void CAknViewAppUi::ActivateLocalViewL( TUid aViewId, TUid aCustomMessageId, const TDesC8& aCustomMessage )

	{

	ActivateViewL( TVwsViewId( Application()->AppDllUid(), aViewId ), aCustomMessageId, aCustomMessage );

#ifdef RD_SPLIT_VIEW

    const TAknSplitViewContainer* splitView( SplitView( aViewId ) );

	if ( splitView )

	    {

        CAknEnv::Static()->SplitViewActive( ETrue );

        if ( !ViewShown( splitView->iViewIds[0] ) || !ViewShown( splitView->iViewIds[1] ) )

            {

            iExtension->iFlags |= EAknViewAppUiFromSingleToSplit;

            }

	    }

#endif // RD_SPLIT_VIEW	    

	}

// -----------------------------------------------------------------------------

// CAknViewAppUi::HandleStatusPaneSizeChange

// Called by the framework when status pane's position or size changes.

// -----------------------------------------------------------------------------

//

EXPORT_C void CAknViewAppUi::HandleStatusPaneSizeChange()

	{

	if (iClearer)

		{

		TRAP_IGNORE(iClearer->HandleStatusPaneSizeChangeL());

		}

	const TInt count( iViews->Count() );

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

		{

		iViews->At( i )->HandleStatusPaneSizeChange();

		}

	}

// -----------------------------------------------------------------------------

// CAknViewAppUi::ViewActivatedL

// Adds a view to the activation queue. 

// -----------------------------------------------------------------------------

//

void CAknViewAppUi::ViewActivatedL( CAknView* aView, const TVwsViewId& aPrevViewId, TUid aCustomMessageId, const TDesC8& aCustomMessage )

	{

	CViewActivationItem* activation( CViewActivationItem::NewLC( aView, aCustomMessageId, aCustomMessage, aPrevViewId ) );

	iActivationQueue->AppendL( activation );

	CleanupStack::Pop(); // activation

	QueueActivationTick();

	}

// -----------------------------------------------------------------------------

// CAknViewAppUi::ViewDeactivated

// An empty implementation.

// -----------------------------------------------------------------------------

//

void CAknViewAppUi::ViewDeactivated( CAknView* /*aView*/ )

	{

	// SERIES60 apps always have at least one active view.

	}

// -----------------------------------------------------------------------------

// CAknViewAppUi::HandleForegroundEventL

// Called by the framework when view's foreground status changes.

// -----------------------------------------------------------------------------

//

EXPORT_C void CAknViewAppUi::HandleForegroundEventL( TBool aForeground )

	{

	CAknAppUi::HandleForegroundEventL( aForeground );

	if ( iView )

	    {

		iView->ProcessForegroundEventL( aForeground );

	    }