/*

* Copyright (c) 2002-2008 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 for tab navigation control.

*

*/

// SYSTEM INCLUDE FILES

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <uikon/eikdefmacros.h>

#endif

#include <w32std.h>

#include <barsread.h>

#include <eikbctrl.h>

#include <eiklabel.h>

#include <eikimage.h>

#include <eikenv.h>

#include <AknLayoutDef.h>

#include <AknsUtils.h>

#include <AknIconUtils.h>

#include <AknDef.h>

#include <e32std.h>

#include <AknStatuspaneUtils.h>

#include <layoutmetadata.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <akniconconfig.h>

#include <AknTasHook.h>

#include <touchfeedback.h>

// USER INCLUDE FILES

#include "aknappui.h"

#include "avkon.hrh"

#include "AknNaviObserver.h"

#include "AknPanic.h"

#include "akntabgrp.h"

#include "AknTabObserver.h"

#include "aknenv.h"

#include "AknBitmapMirrorUtils.h"

#include "AknTabGrpGraphics.h"

#include "aknnavide.h"

#include "AknNaviDecoratorObserver.h"

// GLOBAL CONSTANTS

const TInt KTabArrayGranularity             = 4;

const TInt KAknTabGroupNoTabs               = KErrNotFound;

const TInt KTabColorBitmapQueueGranularity  = 2;

const TInt KTabColorBitmapActiveColorIndex  = 0;

const TInt KTabColorBitmapPassiveColorIndex = 1;

/** Maximum number of tabs that can be shown in the tab group at a time. */

const TInt KMaxNumberOfVisibleTabs          = 4;

/** Maximum number of frames in the tab group animations. */

const TInt KMaxAmountOfAnimationEvents      = 80;

/** Interval used between the frames in tab group animations. */

const TInt KAnimationEventInterval          = 25000; // 40 events/s

/** Speed value for the layout switch animation, smaller value is faster. */

const TInt KLayoutSwitchAnimationSpeed      = 25;

/** Minimum horizontal step size value for the tab cycle animation. */

const TInt KMinimumCycleAnimationStepSize   = 3;

/** Tolerance used for pointer event position's x-value in tab navigation. */

const TInt KDragNavigationTolerance         = 5;

//

// Extension to CAknTab

//

NONSHARABLE_CLASS( CAknTabExtension ) : public CBase

    {

public:

    static CAknTabExtension* NewL();

    ~CAknTabExtension();

private:

    CAknTabExtension();

public:

    /** Indicates whether or not the tab is shown in narrow tab group layout. */

    TBool iNarrowTabLayout;

    /** Total amount of tab in the tab group, needed to decide right layoutlines. */

    TInt  iNumberOfTabsInTabGroup;

    /** Indicates whether or not this tab is drawn using multi-color mode. */

    TBool iMultiColorMode;

    /** Indicates whether or not the tab is shown in long tab group layout. */

    TBool iLongTab;

    };

CAknTabExtension* CAknTabExtension::NewL()

    {

    CAknTabExtension* self = new ( ELeave ) CAknTabExtension();

    return self;

    }

CAknTabExtension::CAknTabExtension()

    {

    }

CAknTabExtension::~CAknTabExtension()

    {

    }

//

// CAknTab

//

CAknTab::~CAknTab()

    {

    AKNTASHOOK_REMOVE();

    delete iLabel;

    delete iBitmap;

    delete iBitmapMask;

    if ( iColorBitmaps )

        {

        iColorBitmaps->ResetAndDestroy();

        delete iColorBitmaps;

        iColorBitmaps = NULL;

        }

    delete iExtension;

    }

CAknTab* CAknTab::NewL( const CCoeControl& aParent, TResourceReader& aReader )

    {

    CAknTab* self = CAknTab::NewLC( aParent, aReader );

    CleanupStack::Pop( self );

    return self;

    }

CAknTab* CAknTab::NewLC( const CCoeControl& aParent, TResourceReader& aReader )

    {

    CAknTab* self = new (ELeave) CAknTab( 0 ); // default tab id

    CleanupStack::PushL( self );

    self->SetContainerWindowL( aParent );

    self->ConstructFromResourceL( aReader );

    AKNTASHOOK_ADDL( self, "CAknTab" );

    return self;

    }

CAknTab* CAknTab::NewL( TInt aId,

                        const CCoeControl& aParent,

                        const TDesC& aTabText )

    {

    CAknTab* self = CAknTab::NewLC( aId, aParent, aTabText );

    CleanupStack::Pop( self );

    return self;

    }

CAknTab* CAknTab::NewLC( TInt aId,

                         const CCoeControl& aParent,

                         const TDesC& aTabText )

    {

    CAknTab* self = new (ELeave) CAknTab( aId );

    CleanupStack::PushL( self );

    self->SetContainerWindowL( aParent );

    self->ConstructL( aTabText );

    AKNTASHOOK_ADDL( self, "CAknTab" );

    return self;

    }

CAknTab* CAknTab::NewL( TInt aId,

                        const CCoeControl& aParent,

                        const TDesC& aTabText,

                        const CFbsBitmap* aTabBitmap,

                        const CFbsBitmap* aMask )

    {

    CAknTab* self = CAknTab::NewLC( aId, aParent, aTabText, aTabBitmap, aMask );

    CleanupStack::Pop( self );

    return self;

    }

CAknTab* CAknTab::NewLC( TInt aId,

                         const CCoeControl& aParent,

                         const TDesC& aTabText,

                         const CFbsBitmap* aTabBitmap,

                         const CFbsBitmap* aMask )

    {

    CAknTab* self = new (ELeave) CAknTab( aId );

    CleanupStack::PushL( self );

    self->SetContainerWindowL( aParent );

    self->ConstructL( aTabText );

    self->ConstructL( aTabBitmap, aMask );

    AKNTASHOOK_ADDL( self, "CAknTab" );

    return self;

    }

CAknTab* CAknTab::NewL( TInt aId,

                        const CCoeControl& aParent,

                        const CFbsBitmap* aTabBitmap,

                        const CFbsBitmap* aMask )

    {

    CAknTab* self = CAknTab::NewLC( aId, aParent, aTabBitmap, aMask );

    CleanupStack::Pop( self );

    return self;

    }

CAknTab* CAknTab::NewLC( TInt aId,

                         const CCoeControl& aParent,

                         const CFbsBitmap* aTabBitmap,

                         const CFbsBitmap* aMask )

    {

    CAknTab* self = new (ELeave) CAknTab( aId );

    CleanupStack::PushL( self );

    self->SetContainerWindowL( aParent );

    self->ConstructL( aTabBitmap, aMask );

    AKNTASHOOK_ADDL( self, "CAknTab" );

    return self;

    }

CAknTab::CAknTab( TInt aId ) : iId( aId )

    {

    }

void CAknTab::ConstructFromResourceL( TResourceReader& aReader )

    {

    if ( !iExtension )

        {

        iExtension = CAknTabExtension::NewL();

        }

    iId = aReader.ReadInt16(); // tab id

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

    if ( txt )

        {

        CleanupStack::PushL( txt );

        ConstructL( *txt );

        CleanupStack::PopAndDestroy( txt );

        }

    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::CreateIconLC( bitmap,

                                            mask,

                                            fileName,

                                            bitmapId,

                                            maskId );

                CleanupStack::Pop( mask );

                CleanupStack::Pop( bitmap );

                // moves ownership of bitmap and mask at beginning =>

                // no need to have bitmap/mask in cleanupstack

                ConstructL( bitmap, mask );

                }

            else

                {

                bitmap = AknIconUtils::CreateIconL( fileName, bitmapId );

                // moves ownership of bitmap and mask at beginning =>

                // no need to have bitmap/mask in cleanupstack

                ConstructL( bitmap );

                }

            }

        CleanupStack::PopAndDestroy( bitmapFile );  // bitmapFile

        }

    LoadColorBitmapL();

    }

void CAknTab::ConstructL( const TDesC& aTabText )

    {

    if ( !iExtension )

        {

        iExtension = CAknTabExtension::NewL();

        }

    iLabel = new (ELeave) CEikLabel;

    iLabel->SetContainerWindowL( *this );

    iLabel->SetTextL( aTabText );

    iLabel->SetAlignment( EHCenterVCenter );

    iLabel->SetAllMarginsTo( KNaviTabMargins );

    if ( AknLayoutUtils::Variant() == EEuropeanVariant )

        {

        iLabel->SetFont( LatinBold12() );

        }

    else    // APAC

        {

        iLabel->SetFont( ApacPlain12() );

        }

    LoadColorBitmapL();

    }

void CAknTab::ConstructL( const CFbsBitmap* aTabBitmap,

                          const CFbsBitmap* aMask )

    {

    if ( !iExtension )

        {

        iExtension = CAknTabExtension::NewL();

        }

    iBitmap = aTabBitmap;

    iBitmapMask = aMask;

    LoadColorBitmapL();

    }

void CAknTab::ReplaceTextL( const TDesC& aTabText )

    {

    if ( iLabel )

        {

        iLabel->SetTextL( aTabText );

        }

    }

void CAknTab::SetActive( TBool aActive, TDrawNow aDrawNow )

    {

    iActive = aActive;

    if ( aDrawNow == EDrawNow )

        {

        DrawNow();

        }

    }

TBool CAknTab::Active() const

    {

    return iActive;

    }

TInt CAknTab::Id() const

    {

    return iId;

    }

enum CAknTab::TAknTabDataType CAknTab::TabType() const

    {

    TAknTabDataType tabType( EAknTabNone );

    if ( iLabel && iBitmap )

        {

        tabType = EAknTabTextAndIcon;

        }

    else if ( iBitmap )

        {

        tabType = EAknTabIcon;

        }

    else if ( iLabel )

        {

        tabType = EAknTabText;

        }

    return tabType;

    }

TSize CAknTab::MinimumSize()

    {

    TSize minSize;

    if ( iLabel )

        {

        minSize += iLabel->MinimumSize();

        }

    if ( iBitmap )

        {

        minSize += iBitmap->SizeInPixels();

        }

    return minSize;

    }

void CAknTab::SetDimmed( TBool aDimmed )

    {

    CCoeControl::SetDimmed( aDimmed );

    if ( iLabel )

        {

        iLabel->SetDimmed( aDimmed );

        }

    }

void CAknTab::GetColorUseListL( CArrayFix<TCoeColorUse>& aColorUseList ) const

    {

    TCoeColorUse colorUse;

    colorUse.SetLogicalColor( EColorDialogBackground );

    colorUse.SetUse( TCoeColorUse::EBack |

                     TCoeColorUse::ESurrounds |

                     TCoeColorUse::EActive |

                     TCoeColorUse::ENormal |

                     TCoeColorUse::ENeutral );

    aColorUseList.AppendL( colorUse );

    }

void CAknTab::SizeChanged()

    {

    if ( AknStatuspaneUtils::FlatLayoutActive() &&

         !iExtension->iNarrowTabLayout )

        {

        SizeChangedInFlatLayout();

        }

    else if ( iExtension->iNarrowTabLayout )

        {

        SizeChangedInNarrowLayout();

        }

    else

        {

        SizeChangedInNormalLayout();

        }

    }

void CAknTab::SizeChangedInNormalLayout()

    {

    if ( !iColorBitmaps )

        {

        TRAP_IGNORE( LoadColorBitmapL() );

        }

    TBool landscape( Layout_Meta_Data::IsLandscapeOrientation() );

    TBool staconPaneActive( AknStatuspaneUtils::StaconPaneActive() );

    TBool longTab( iExtension && iExtension->iLongTab );

    TRect rect( Rect() );

    if ( iLabel && iBitmap )

        {

        iBitmapRect.LayoutRect(

            rect,

            AknLayoutScalable_Avkon::navi_navi_icon_text_pane_g1() );

        AknIconUtils::SetSize( const_cast<CFbsBitmap*> ( iBitmap ),

                               iBitmapRect.Rect().Size() );

        AknLayoutUtils::LayoutLabel(

            iLabel,

            rect,

            AknLayoutScalable_Avkon::navi_navi_icon_text_pane_t1() );

        iLabel->CropText();

        }

    else

        {

        if ( iLabel )

            {

            TAknTextComponentLayout textLayout;

            switch ( iExtension->iNumberOfTabsInTabGroup )

                {

                case 1:

                    {

                    textLayout =

                        AknLayoutScalable_Avkon::tabs_2_long_active_pane_t1(

                            landscape );

                    break;

                    }

                case 2:

                    {

                    if ( longTab )

                        {

                        textLayout =

                            AknLayoutScalable_Avkon::tabs_2_long_active_pane_t1(

                                landscape );

                        }

                    else

                        {

                        if ( iActive )

                            {

                            textLayout =

                                AknLayoutScalable_Avkon::tabs_2_active_pane_t1(

                                    landscape );

                            }

                        else

                            {

                            textLayout =

                                AknLayoutScalable_Avkon::tabs_2_passive_pane_t1(

                                    landscape );

                            }

                        }

                    break;

                    }

                case 3:

                    {

                    if ( longTab )

                        {

                        textLayout =

                            AknLayoutScalable_Avkon::tabs_3_long_active_pane_t1(

                                landscape );

                        }

                    else

                        {

                        if ( iActive )

                            {

                            textLayout =

                                AknLayoutScalable_Avkon::tabs_3_active_pane_t1(

                                    landscape );

                            }

                        else

                            {

                            textLayout =