/*

* Copyright (c) 2002-2005 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: 

*

*/

// AknView.cpp

//

// Copyright (c) 1997-2001 Symbian Ltd.  All rights reserved.

//

// INCLUDE FILES

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <uikon/eikdefmacros.h>

#endif

#include "aknview.h"

#include "aknViewAppUi.h"

#include "AknPanic.h"

#include "avkon.hrh"

#include "aknenv.h"

#include <eikenv.h>

#include <eikapp.h>

#include <barsread.h>

#include <eikmenub.h>

#include <eikcba.h>

#include <eikmop.h>

#include <eikcolib.h>

#include <akntoolbar.h>

#include <AknPriv.hrh>

#ifdef RD_SCALABLE_UI_V2

#include <akntouchpane.h>

#endif // RD_SCALABLE_UI_V2

#include <AknUtils.h>

#include "aknitemactionmenuregister.h"

// MODULE DATA STRUCTURES

enum TAknViewFlags

	{

	EAknViewForeground

	};

// CLASS DECLARATION

/**

* Extension class.

*/

NONSHARABLE_CLASS(CAknViewExtension) : public CBase

    {

    public:

        static CAknViewExtension* NewL(CAknView* aView);

        ~CAknViewExtension();

    private:

        CAknViewExtension(CAknView* aView);

        void ConstructL();

        void ChangeToolbar( CAknToolbar* aOldToolbar ); 

    public:

        void CreateToolbarL( TInt aResourceId );

        void PrepareToolbar();

        void DestroyToolbars();

        void StopDisplayingToolbar( TBool aAlways );

        void StopDisplayingFixedToolbar();

        CAknToolbar* Toolbar() const;

        void SetToolbar( CAknToolbar* aToolbar ); 

        void CreateAndSetToolbarL( TInt aResourceId ); 

    public:

        TBool iToolbarVisible; 

        TBool iToolbarFocusing; 

    private: // data

        CAknToolbar* iToolbar;

        CAknToolbar* iFixedToolbar;

        CAknView* iView;

    };

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

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

// CAknViewExtension::CAknViewExtension

// C++ default constructor.

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

//

CAknViewExtension::CAknViewExtension(CAknView* aView)

: iView(aView)

	{

	}

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

// CAknViewExtension::~CAknViewExtension

// Destructor.

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

//

CAknViewExtension::~CAknViewExtension()

    {

    DestroyToolbars();

    }

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

// CAknViewExtension::NewL

// Symbian two-phased constructor.

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

//

CAknViewExtension* CAknViewExtension::NewL(CAknView* aView)

	{

	CAknViewExtension* ext = new ( ELeave ) CAknViewExtension(aView);

	CleanupStack::PushL( ext );

	ext->ConstructL();

	CleanupStack::Pop(); // ext

	return ext;

	}

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

// CAknViewExtension::ConstructL

// Symbian 2nd stage constructor.

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

//

void CAknViewExtension::ConstructL()

	{

	}

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

// CAknViewExtension::CreateToolbarL

// toolbar is created from the resource files.

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

//

void CAknViewExtension::CreateToolbarL( TInt aResourceId )

    {

    if ( aResourceId )

    	{

    	if ( !iToolbar )

        	{

            iToolbar = CAknToolbar::NewL( aResourceId );

            iToolbar->SetMopParent( iView );

#ifdef RD_SCALABLE_UI_V2

            CAknTouchPane* touchPane = static_cast<CEikAppUiFactory*>( 

                CEikonEnv::Static()->AppUiFactory() )->TouchPane(); 

            if ( touchPane )

                {

                iToolbar->SetObserver( touchPane );

                }

            // Checking if toolbar is fixed so setting it to iFixedToolbar

            if ( iToolbar->ToolbarFlags() & KAknToolbarFixed )

                {

                iFixedToolbar = iToolbar; 

                iToolbar = NULL; 

                }

#endif // RD_SCALABLE_UI_V2

            }

    	}

    }

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

// CAknViewExtension::PrepareToolbar

// application informed and the old toolbar is hidden

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

//

void CAknViewExtension::PrepareToolbar()

    {

    CAknToolbar* oldCurrentToolbar = static_cast<CEikAppUiFactory*>( 

        CEikonEnv::Static()->AppUiFactory() )->CurrentPopupToolbar();

    // set view specific toolbar	

    static_cast<CEikAppUiFactory*>( 

        CEikonEnv::Static()->AppUiFactory() )->SetViewPopupToolbar( iToolbar );

    CAknToolbar* newToolbar = static_cast<CEikAppUiFactory*>( 

        CEikonEnv::Static()->AppUiFactory() )->CurrentPopupToolbar();

    if ( oldCurrentToolbar && oldCurrentToolbar != newToolbar )

        {

        oldCurrentToolbar->SetToolbarVisibility( EFalse );

        }

    if ( newToolbar )

        {

#ifdef RD_SCALABLE_UI_V2

        if ( !iToolbarFocusing && iToolbarVisible )

            {

            newToolbar->SetToolbarVisibility( ETrue, EFalse ); 

            }

        else 

#endif //RD_SCALABLE_UI_V2

            {

            newToolbar->SetToolbarVisibility( iToolbarVisible ); 

            }

        }

#ifdef RD_SCALABLE_UI_V2

    // Here is code for fixed toolbar

    CAknToolbar* oldFixedToolbar = static_cast<CEikAppUiFactory*>( 

        CEikonEnv::Static()->AppUiFactory() )->CurrentFixedToolbar();

    // set view specific fixed toolbar	

    static_cast<CEikAppUiFactory*>( 

        CEikonEnv::Static()->AppUiFactory() )->SetViewFixedToolbar( iFixedToolbar );

    CAknToolbar* newFixedToolbar = static_cast<CEikAppUiFactory*>( 

        CEikonEnv::Static()->AppUiFactory() )->CurrentFixedToolbar();

    if ( newFixedToolbar )

        {

        newFixedToolbar->HandleResourceChange( KAknToolbarSetVisible );

        }

    if ( oldFixedToolbar && oldFixedToolbar != newFixedToolbar )

        {

        if ( newFixedToolbar && newFixedToolbar->ToolbarFlags() & KAknToolbarDefault )

        	{

        	oldFixedToolbar->HandleResourceChange( KAknToolbarSetHiddenAndDrawBackground );

        	return;

        	}

        oldFixedToolbar->HandleResourceChange( KAknToolbarSetHidden );         

        }

#endif 

    }

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

// CAknViewExtension::DestroyToolbar

// toolbar is created from the resource files.

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

//

void CAknViewExtension::DestroyToolbars()

    {

    delete iToolbar;

    iToolbar = NULL;

    static_cast<CEikAppUiFactory*>( 

        CEikonEnv::Static()->AppUiFactory() )->SetViewPopupToolbar( NULL );

    delete iFixedToolbar; 

    iFixedToolbar = NULL; 

    }

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

// CAknViewExtension::StopDisplayingToolbar

// toolbar is hidden.

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

//

void CAknViewExtension::StopDisplayingToolbar( TBool aAlways )

    {

    if ( iToolbar )

        {

        if ( aAlways || ( iToolbar->ToolbarFlags() & KAknToolbarFixed ) )

            {

            iToolbar->SetToolbarVisibility( EFalse );

            }

        }

    }

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

// CAknViewExtension::TryDisplayToolbar

// Toolbar is hidden.

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

//

void CAknViewExtension::StopDisplayingFixedToolbar()

    {

    if ( iFixedToolbar )

        {

        iFixedToolbar->SetToolbarVisibility( EFalse );

        }

    }

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

// CAknViewExtension::Toolbar

// Return toolbar object, either floating of fixed

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

//

CAknToolbar* CAknViewExtension::Toolbar() const

    {

    if ( iToolbar )

        {

        return iToolbar;

        }

    else

        {

        return iFixedToolbar; 

        }

    }

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

// CAknViewExtension::SetToolbar

// Sets toolbar for view

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

//

void CAknViewExtension::SetToolbar( CAknToolbar* aToolbar )

    {

    CAknToolbar* oldToolbar = NULL; 

    if ( iToolbar )

        {

        oldToolbar = iToolbar;

        iToolbar = NULL;

        }

    if ( iFixedToolbar )

        {

        oldToolbar = iFixedToolbar; 

        iFixedToolbar = NULL; 

        }

    if ( aToolbar && aToolbar->ToolbarFlags() & KAknToolbarFixed )

        {

        iFixedToolbar = aToolbar; 

        }

    else if ( aToolbar )

        {

        iToolbar = aToolbar; 

        }

    ChangeToolbar( oldToolbar ); 

    }

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

// CAknViewExtension::CreateAndSetToolbar

// Creates and sets toolbar for the view

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

//

void CAknViewExtension::CreateAndSetToolbarL( TInt aResourceId )

    {

    CAknToolbar* oldToolbar = NULL; 

    if ( iToolbar )

        {

        oldToolbar = iToolbar;

        iToolbar = NULL;  

        }

    if ( iFixedToolbar )

        {

        oldToolbar = iFixedToolbar; 

        iFixedToolbar = NULL; 

        }

    CreateToolbarL( aResourceId ); 

    ChangeToolbar( oldToolbar ); 

    }

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

// CAknViewExtension::ChangeToolbar

// Changes current toolbar. If old toolbar was visible, then the new will 

// also be shown. 

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

//

void CAknViewExtension::ChangeToolbar( CAknToolbar* aOldToolbar )

    {

    TBool shown(EFalse); 

    if ( aOldToolbar )

        {

        if ( aOldToolbar->IsShown() )

            {

            shown = ETrue; 

            }

        }

    if ( iToolbar )

        {

        static_cast<CEikAppUiFactory*>( 

            CEikonEnv::Static()->AppUiFactory() )->SetViewPopupToolbar( iFixedToolbar );

        if ( shown )

            {

#ifdef RD_SCALABLE_UI_V2

            iToolbar->SetToolbarVisibility( ETrue, iToolbarFocusing ); 

#endif //RD_SCALABLE_UI_V2

            iToolbar->SetToolbarVisibility( ETrue ); 

            }

        }

    if ( iFixedToolbar )

        {

        static_cast<CEikAppUiFactory*>( 

            CEikonEnv::Static()->AppUiFactory() )->SetViewFixedToolbar( iFixedToolbar );

        if ( shown )

            {

            iFixedToolbar->HandleResourceChange( KAknToolbarSetVisible );

            }

        }

    delete aOldToolbar; 

    aOldToolbar = NULL; 

    }

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

// CAknView::CAknView

// C++ default constructor.

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

//

EXPORT_C CAknView::CAknView() : iCoeEnv( CCoeEnv::Static() ), 

  iAppUi( (CAknViewAppUi*)(CEikonEnv::Static()->EikAppUi()) )

	{

	}

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

// CAknView::~CAknView

// Destructor.

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

//

EXPORT_C CAknView::~CAknView()

	{

	if ( iMenu )

		{

		iAppUi->RemoveFromStack( iMenu );

		delete iMenu;

		}

	delete iCba;

	delete iExtension;

	}

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

// CAknView::BaseConstructL

// Second-phase base class constructor. Must be called from a derived classes

// second stage construction function.

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

//

EXPORT_C void CAknView::BaseConstructL( TInt aResId )

	{

	iExtension = CAknViewExtension::NewL( this );

	if ( aResId )

		{

		// If this assert fails, you have probably constructed your view twice

		ASSERT(!iViewInfo.iMenu && !iViewInfo.iCba && !iViewInfo.iHotKeys);

        TResourceReader r;

        iCoeEnv->CreateResourceReaderLC( r, aResId );

        iViewInfo.iVersion = r.ReadInt8();

        iViewInfo.iHotKeys = r.ReadInt32();

        iViewInfo.iMenu = r.ReadInt32();

        iViewInfo.iCba = r.ReadInt32();

        iViewInfo.iToolbar = r.ReadInt32();

        r.ReadInt32(); // extension

        CleanupStack::PopAndDestroy(); // r

        }

    Extension()->CreateToolbarL( iViewInfo.iToolbar );

    }

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

// CAknView::AppUi

// Accessor for the app UI as a CAknViewAppUi.

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

//

EXPORT_C CAknViewAppUi* CAknView::AppUi() const

	{

	return iAppUi;

	}

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

// CAknView::ActivateViewL

// Activates any view in the product.

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

//

EXPORT_C void CAknView::ActivateViewL( const TVwsViewId& aViewId )

	{

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

	Extension();

	iAppUi->ActivateViewL( aViewId );

	}

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

// CAknView::ActivateViewL

// Activates any view in the product and passes a message.

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

//

EXPORT_C void CAknView::ActivateViewL( const TVwsViewId& aViewId, TUid aCustomMessageId, const TDesC8& aCustomMessage )

	{

	iAppUi->ActivateViewL( aViewId, aCustomMessageId, aCustomMessage );

	}

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

// CAknView::StatusPane

// Status pane accessor method.

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

//

EXPORT_C CEikStatusPane* CAknView::StatusPane() const

	{

	return iAppUi->StatusPane();

	}

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

// CAknView::Cba

// CBA accessor method. This returns view's CBA if there is one. Otherwise UI's

// CBA is returned.

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

//

EXPORT_C CEikButtonGroupContainer* CAknView::Cba() const

	{

	if ( iCba )

	    {

		return iCba;

	    }

	return iAppUi->Cba();

	}

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

// CAknView::HandleStatusPaneSizeChange

// Event handler for status pane size changes. The default implementation is

// empty.