/*

* 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:  Implementation of the navi pane container control.

*

*/

// SYSTEM INCLUDE FILES

#include <eikfutil.h>

#include <eiklabel.h>

#include <eikimage.h>

#include <layoutmetadata.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <fbs.h>

#include <avkon.rsg>

#include <centralrepository.h>

#include <AknSkinsInternalCRKeys.h>

#include <AknsDrawUtils.h>

#include <AknsLayeredBackgroundControlContext.h>

#include <mifconvdefs.h>

#include <akniconconfig.h>

#include <AknTasHook.h>

// USER INCLUDE FILES

#include "aknenv.h"

#include "AknDef.h"

#include "aknappui.h"

#include "aknconsts.h"

#include "akntabgrp.h"

#include "aknnavide.h"

#include "AknIndicatorContainer.h"

#include "AknVolumePopup.h"

#include "AknUtils.h"

#include "AknBitmapMirrorUtils.h"

#include "avkon.hrh"

#include "aknnavi.h"

#include "aknnavilabel.h"

#include "akncontext.h"

#include "AknSignalNotify.h"

#include "AknNaviForegroundObserver.h"

#include "AknNaviConstants.h"

#include "aknEditStateIndicator.h"

#include "AknStatuspaneUtils.h"

#include "akntitle.h"

#include "AknTitlePaneLabel.h"

#include "AknDebug.h"

const TInt KAknNaviPaneStackGranularity = 2;

#define Min( x , y ) ((( x ) < ( y )) ? ( x ) : ( y ))

/**

* Extension class for CAknNavigationControlContainer.

*/

class CAknNavigationControlContainerExtension : public CBase

    {

public:

    CAknNavigationControlContainerExtension(){};

    ~CAknNavigationControlContainerExtension(){};

public:

    TInt                        iCurrentColorScheme;

    CAknNaviForegroundObserver* iForegroundObserver;

    TBool                       iDestructionOngoing;

    CFbsBitmap*                 iNaviColorBitmap;

    TInt                        iPreferredNaviDecoratorLayoutStyle;

    CEikStatusPaneBase*         iStatusPane;

    };

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

// CAknNavigationControlContainer::CAknNavigationControlContainer

// Default constructor.

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

//

EXPORT_C CAknNavigationControlContainer::CAknNavigationControlContainer() :

    iStatusPane( CEikStatusPaneBase::Current() )

    {

    AKNTASHOOK_ADD( this, "CAknNavigationControlContainer" );

    }

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

// CAknNavigationControlContainer::~CAknNavigationControlContainer

// Destructor.

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

//

EXPORT_C CAknNavigationControlContainer::~CAknNavigationControlContainer()

    {

    AKNTASHOOK_REMOVE();

    if ( iExtension )

        {

        iExtension->iDestructionOngoing = ETrue;

        }

    AknsUtils::DeregisterControlPosition( this );

    delete iNaviDecoratorFromResource;

    if ( iNaviPaneControls )

        {

        const TInt last = iNaviPaneControls->Count() - 1;

        TInt ii = 0;

        for ( ii = last; ii >= 0; ii-- )

            {

            Pop( iNaviPaneControls->At( ii ) );

            }

        delete iNaviPaneControls;

        }

    for ( TInt jj = 0; jj < 4; jj++ )

        {

        delete iNaviArrowBitmap[ jj ];

        }

    if ( iExtension )

        {

        delete iExtension->iForegroundObserver;

        delete iExtension->iNaviColorBitmap;

        delete iExtension;

        }

    }

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

// CAknNavigationControlContainer::ConstructL

// Second-phase constructor.

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

//

EXPORT_C void CAknNavigationControlContainer::ConstructL()

    {

    if ( !iExtension )

        {

        iExtension =

            new (ELeave) CAknNavigationControlContainerExtension();

        iExtension->iCurrentColorScheme = ColorScheme();

        iExtension->iForegroundObserver =

            CAknNaviForegroundObserver::NewL( this );

        iExtension->iStatusPane = CEikStatusPaneBase::Current();

        }

    if ( !iNaviPaneControls )

        {

        iNaviPaneControls =

            new (ELeave) CAknNaviPaneStack( KAknNaviPaneStackGranularity );

        }

    // creating color bitmap

    LoadNaviColorBitmapL();

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    AknsUtils::CreateIconL( skin,

                            KAknsIIDQgnIndiNaviArrowLeft,

                            iNaviArrowBitmap[ 0 ],

                            iNaviArrowBitmap[ 1 ],

                            KAvkonBitmapFile,

                            EMbmAvkonQgn_indi_navi_arrow_left,

                            EMbmAvkonQgn_indi_navi_arrow_left_mask );

    AknsUtils::CreateIconL( skin,

                            KAknsIIDQgnIndiNaviArrowRight,

                            iNaviArrowBitmap[ 2 ],

                            iNaviArrowBitmap[ 3 ],

                            KAvkonBitmapFile,

                            EMbmAvkonQgn_indi_navi_arrow_right,

                            EMbmAvkonQgn_indi_navi_arrow_right_mask );

    }

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

// CAknNavigationControlContainer::ConstructFromResourceL

// Resource constructor.

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

//

EXPORT_C void CAknNavigationControlContainer::ConstructFromResourceL(

    TResourceReader& aReader )

    {

    ConstructL();

    iNaviDecoratorFromResource =

        ConstructNavigationDecoratorFromResourceL( aReader );

    if ( iNaviDecoratorFromResource )

        {

        PushL( *iNaviDecoratorFromResource );

        }

    }

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

// CAknNavigationControlContainer::ConstructNavigationDecoratorFromResourceL

// Creates a decorated navi pane control from resource.

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

//

EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::ConstructNavigationDecoratorFromResourceL(

    TResourceReader& aReader )

    {

    TInt controlType = aReader.ReadInt16(); // type

    CAknNavigationDecorator* decoratedNaviObject = NULL;

    switch ( controlType )

        {

        case ENaviDecoratorControlNone:

            {

            PushDefaultL();

            break;

            }

        case ENaviDecoratorControlTabGroup:

            {

            decoratedNaviObject  = CreateTabGroupL( aReader );

            break;

            }

        case ENaviDecoratorLabel:

            {

            decoratedNaviObject  = CreateNavigationLabelL( aReader );

            break;

            }

        case ENaviDecoratorImage:

            {

            decoratedNaviObject  = CreateNavigationImageL( aReader );

            break;

            }

        case ENaviDecoratorToolTip:

            {

            decoratedNaviObject  = CreateMessageLabelL( aReader );

            break;

            }

        default:

            {

            break;

            }

        }

    return decoratedNaviObject;

    }

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

// CAknNavigationControlContainer::CreateTabGroupL

// Creates a decorated tab group control to use in navi pane.

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

//

EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::CreateTabGroupL()

    {

    TBool penEnabled( AknLayoutUtils::PenEnabled() );

    CAknTabGroup* tabGroup = CAknTabGroup::NewL( *this );

    // Tab group to the clean up stack in first line of NewL function.

    CAknNavigationDecorator* decoratedTabGroup =

        CAknNavigationDecorator::NewL( this,

                                       tabGroup,

                                       CAknNavigationDecorator::ETabGroup );

    if ( penEnabled )

        {

        // Set tab group as an observer of the decorator for right/left

        // arrows tapping.

        decoratedTabGroup->SetNaviDecoratorObserver( tabGroup );

        }

    CleanupStack::PushL( decoratedTabGroup );

    decoratedTabGroup->SetContainerWindowL( *this );

    // Navi arrows are not used for tab group in touch layouts.

    decoratedTabGroup->MakeScrollButtonVisible( !penEnabled );

    tabGroup->SetRect(

        CAknNavigationDecorator::DecoratedTabControlRect(

            !AknStatuspaneUtils::UsualLayoutActive(),

            !penEnabled ) );

    CleanupStack::Pop( decoratedTabGroup );

    decoratedTabGroup->SetObserver( this );

    return decoratedTabGroup;

    }

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

// CAknNavigationControlContainer::CreateTabGroupL

// Creates a decorated tab group control to use in navi pane.

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

//

EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::CreateTabGroupL(

    MAknTabObserver *aObserver )

    {

    CAknNavigationDecorator* navDec = CreateTabGroupL();

    CAknTabGroup* tabGroup =

        static_cast<CAknTabGroup*>( navDec->DecoratedControl() );

    tabGroup->SetObserver( aObserver );

    return navDec;

    }

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

// CAknNavigationControlContainer::CreateTabGroupL

// Creates a decorated tab group control to use in navi pane.

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

//

EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::CreateTabGroupL(

    TResourceReader& aReader, MAknTabObserver* aObserver )

    {

    CAknNavigationDecorator *navDec = CreateTabGroupL( aReader );

    CAknTabGroup* tabGroup =

        static_cast<CAknTabGroup*>( navDec->DecoratedControl() );

    tabGroup->SetObserver( aObserver );

    return navDec;

    }

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

// CAknNavigationControlContainer::CreateTabGroupL

// Creates a decorated tab group control to use in navi pane.

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

//

EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::CreateTabGroupL(

    TResourceReader& aReader)

    {

    CAknNavigationDecorator* decoratedTabGroup;

    decoratedTabGroup  = CreateTabGroupL();

    CleanupStack::PushL( decoratedTabGroup );

    CAknTabGroup* tabGroup =

        static_cast<CAknTabGroup*>( decoratedTabGroup->DecoratedControl() );

    TInt width = aReader.ReadInt16();

    tabGroup->SetTabFixedWidthL( width );

    TInt activeIndex = aReader.ReadInt16();

    TInt count = aReader.ReadInt16(); // Tab count

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

        {

        tabGroup->AddTabL( aReader );

        }

    tabGroup->SetActiveTabByIndex( activeIndex );

    CleanupStack::Pop( decoratedTabGroup );

    return decoratedTabGroup;

    }

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

// CAknNavigationControlContainer::CreateNavigationLabelL

// Creates a decorated navigation label control to use in navi pane.

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

//

EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::CreateNavigationLabelL(

    const TDesC& aText )

    {

    CAknNaviLabel* label = new (ELeave) CAknNaviLabel;

    CleanupStack::PushL( label );

    label->SetContainerWindowL( *this );

    label->SetTextL( aText );

    label->SetNaviLabelType( CAknNaviLabel::EAdditionalInfoLabel );

    CleanupStack::Pop( label );

    CAknNavigationDecorator* decoratedLabel =

        CAknNavigationDecorator::NewL( this,

                                       label,

                                       CAknNavigationDecorator::ENaviLabel );

    CleanupStack::PushL( decoratedLabel );

    decoratedLabel->SetContainerWindowL( *this );

    decoratedLabel->SetControlContext( this );

    decoratedLabel->MakeScrollButtonVisible( EFalse );

    CleanupStack::Pop( decoratedLabel );

    return decoratedLabel;

    }

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

// CAknNavigationControlContainer::CreateNavigationLabelL

// Creates a decorated navigation label control to use in navi pane.

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

//

EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::CreateNavigationLabelL(

    TResourceReader& aReader )

    {

    HBufC* txt = aReader.ReadHBufCL();  // Label text

    CAknNavigationDecorator* decoratedLabel = NULL;

    if ( txt )

        {

        CleanupStack::PushL( txt );

        decoratedLabel = CreateNavigationLabelL( *txt );

        CleanupStack::PopAndDestroy( txt );

        }

    else

        {

        decoratedLabel = CreateNavigationLabelL( KNullDesC );

        }

    return decoratedLabel;

    }

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

// CAknNavigationControlContainer::CreateNavigationImageL

// Creates a decorated navigation image control to use in navi pane.

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

//

EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::CreateNavigationImageL(

    const CFbsBitmap* aBitmap, const CFbsBitmap* aMaskBitmap )

    {

    CEikImage* image = new (ELeave) CEikImage;

    CleanupStack::PushL( image );

    image->SetContainerWindowL( *this );

    TAknWindowComponentLayout layout;

    if ( AknStatuspaneUtils::StaconPaneActive() )

        {

        layout = TAknWindowComponentLayout::Compose(

                    AknLayoutScalable_Avkon::navi_navi_pane_stacon( 1 ),

                    AknLayoutScalable_Avkon::navi_navi_icon_text_pane() );

        }

    else

        {

        layout = TAknWindowComponentLayout::Compose(

                    AknLayoutScalable_Avkon::navi_navi_pane(),

                    AknLayoutScalable_Avkon::navi_navi_icon_text_pane() );

        }

    TRect parent( Rect() );

    TAknLayoutRect imageLayoutRect;

    imageLayoutRect.LayoutRect( parent, layout );

    TRect imageRect( imageLayoutRect.Rect() );

    image->SetRect( imageRect );

    image->SetPictureOwnedExternally( ETrue );

    image->SetPicture( aBitmap, aMaskBitmap );

    CleanupStack::Pop( image );

    CAknNavigationDecorator* decoratedImage =

        CAknNavigationDecorator::NewL( this,

                                       image,

                                       CAknNavigationDecorator::ENaviImage );

    CleanupStack::PushL( decoratedImage );

    decoratedImage->SetContainerWindowL( *this );

    CleanupStack::Pop( decoratedImage );

    decoratedImage->MakeScrollButtonVisible( EFalse );

    // Ownership of aBitmap and aMaskBitmap is moved to decoratedImage object

    // after all leaving methods.

    image->SetPictureOwnedExternally( EFalse );

    return decoratedImage;

    }

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

// CAknNavigationControlContainer::CreateNavigationImageL

// Creates a decorated navigation image control to use in navi pane.

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

//

EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::CreateNavigationImageL(

    TResourceReader& aReader )

    {

    CAknNavigationDecorator* decoratedLabel = NULL;

    HBufC* bitmapFile = aReader.ReadHBufCL(); // bmp filename

    TInt   bitmapId   = aReader.ReadInt16();  // bmp id

    TInt   maskId     = aReader.ReadInt16();  // bmp mask id

    if ( bitmapFile )

        {

        CleanupStack::PushL( bitmapFile );

        TFileName fileName( *bitmapFile );

        CompleteWithAppPath( fileName );

        if ( bitmapId != KErrNotFound )

            {

            CFbsBitmap* bitmap;

            if ( maskId != KErrNotFound )

                {

                CFbsBitmap* mask;

                AknIconUtils::CreateIconL( bitmap,

                                           mask,

                                           fileName,

                                           bitmapId,

                                           maskId );

                TAknLayoutRect rect;

                TAknWindowComponentLayout layout;

                if ( AknStatuspaneUtils::StaconPaneActive() )

                    {

                    layout = TAknWindowComponentLayout::Compose(

                                AknLayoutScalable_Avkon::navi_navi_pane(),

                                AknLayoutScalable_Avkon::navi_navi_tabs_pane() );

                    }

                else

                    {

                    layout = AknLayoutScalable_Avkon::navi_navi_tabs_pane();

                    }

                rect.LayoutRect( Rect(), layout );