/*

* Copyright (c) 2004-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:  Class for drawing tab graphics.

*

*/

// SYSTEM INCLUDE FILES

#include <avkon.mbg>

#include <fbs.h>

#include <bitdev.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknIconUtils.h>

#include <AknsUtils.h>

#include <layoutmetadata.cdl.h>

#include <akniconconfig.h>

// USER INCLUDE FILES

#include "AknTabGrpGraphics.h"

#include "AknUtils.h"

#include "aknappui.h"

#include "AknStatuspaneUtils.h"

#include "AknDebug.h"

// CONSTANTS

/**

* These are the fading parameters used in drawing the "hidden" tabs.

* The hidden tabs are drawn with faded graphics context to make them

* appear slightly lighter in color than the actual visible tabs and thus to

* make them stand out from them. These values work for most of the themes

* but it would be better if these were defined in the skin content.

* 

* Currently the fading is not used as custom fading parameters are not

* supported by all display drivers (parameters are not used if

* SYMBIAN_USE_FAST_FADING is defined).

*/

//const TUint8 KHiddenFadeBlackMap( 20 );

//const TUint8 KHiddenFadeWhiteMap( 255 );

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

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

// CAknTabGroupGraphics::CAknTabGroupGraphics

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CAknTabGroupGraphics::CAknTabGroupGraphics()

    {

    iTabGroupBackgroundAvailable = ETrue;

    }

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

// CAknTabGroupGraphics::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAknTabGroupGraphics::ConstructL()

    {

    TRAPD( err, LoadTabGraphicsL() );

    if ( err != KErrNone )

        {

        iTabGroupBackgroundAvailable = EFalse;

        }

    }

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

// CAknTabGroupGraphics::NewL

// Two-phased constructor.

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

//

CAknTabGroupGraphics* CAknTabGroupGraphics::NewL()

    {

    CAknTabGroupGraphics* self =

        new (ELeave) CAknTabGroupGraphics();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CAknTabGroupGraphics::~CAknTabGroupGraphics()

    {

    delete iActiveTabLeft;

    delete iActiveTabLeftMask;

    delete iActiveTabMiddle;

    delete iActiveTabMiddleMask;

    delete iActiveTabRight;

    delete iActiveTabRightMask;

    delete iPassiveTabLeft;

    delete iPassiveTabLeftMask;

    delete iPassiveTabMiddle;

    delete iPassiveTabMiddleMask;

    delete iPassiveTabRight;

    delete iPassiveTabRightMask;

    }

void CAknTabGroupGraphics::SetTabGroupBackgroundParent( TRect aParent )

    {

    iTabGroupBackgroundParent = aParent;

    }

#if 0

CAknTabGroupGraphics::SAknTabGroupBackground CAknTabGroupGraphics::CreateTabGroupBackgroundL( TInt aAvkonBitmapId)

    {

    CAknTabGroupGraphics::SAknTabGroupBackground emptyTabGroupBackGround;

    if ( !TabGroupBackgroundAvailable() )

        {

        return emptyTabGroupBackGround;

        }

    TBool longTabs    = EFalse;

    TInt numberOfTabs = 0;

    TInt activeTab    = 0;

    switch ( aAvkonBitmapId )

        {

        case EMbmAvkonQgn_graf_tab_21:

            {

            longTabs     = EFalse;

            numberOfTabs = 2;

            activeTab    = 1;

            break;

            }

        case EMbmAvkonQgn_graf_tab_22:

            {

            longTabs     = EFalse;

            numberOfTabs = 2;

            activeTab    = 2;

            break;

            }

        case EMbmAvkonQgn_graf_tab_31:

            {

            longTabs     = EFalse;

            numberOfTabs = 3;

            activeTab    = 1;

            break;

            }

        case EMbmAvkonQgn_graf_tab_32:

            {

            longTabs     = EFalse;

            numberOfTabs = 3;

            activeTab    = 2;

            break;

            }

        case EMbmAvkonQgn_graf_tab_33:

            {

            longTabs     = EFalse;

            numberOfTabs = 3;

            activeTab    = 3;

            break;

            }

        case EMbmAvkonQgn_graf_tab_41:

            {

            longTabs     = EFalse;

            numberOfTabs = 4;

            activeTab    = 1;

            break;

            }

        case EMbmAvkonQgn_graf_tab_42:

            {

            longTabs     = EFalse;

            numberOfTabs = 4;

            activeTab    = 2;

            break;

            }

        case EMbmAvkonQgn_graf_tab_43:

            {

            longTabs     = EFalse;

            numberOfTabs = 4;

            activeTab    = 3;

            break;

            }

        case EMbmAvkonQgn_graf_tab_44:

            {

            longTabs     = EFalse;

            numberOfTabs = 4;

            activeTab    = 4;

            break;

            }

        case EMbmAvkonQgn_graf_tab_long_21:

            {

            longTabs     = ETrue;

            numberOfTabs = 2;

            activeTab    = 1;

            break;

            }

        case EMbmAvkonQgn_graf_tab_long_22:

            {

            longTabs     = ETrue;

            numberOfTabs = 2;

            activeTab    = 2;

            break;

            }

        case EMbmAvkonQgn_graf_tab_long_31:

            {

            longTabs     = ETrue;

            numberOfTabs = 3;

            activeTab    = 1;

            break;

            }

        case EMbmAvkonQgn_graf_tab_long_32:

            {

            longTabs     = ETrue;

            numberOfTabs = 3;

            activeTab    = 2;

            break;

            }

        case EMbmAvkonQgn_graf_tab_long_33:

            {

            longTabs     = ETrue;

            numberOfTabs = 3;

            activeTab    = 3;

            break;

            }

        default:

            {

            break;

            }

        }

    return CreateTabGroupBackgroundL( longTabs, numberOfTabs, activeTab );

    }

CAknTabGroupGraphics::SAknTabGroupBackground CAknTabGroupGraphics::CreateTabGroupBackgroundL(

    TBool aLongTabs, TInt aNumberOfTabs, TInt aActiveTab )

    {

    CAknTabGroupGraphics::SAknTabGroupBackground       tabGroupBackGround;

    CAknTabGroupGraphics::SAknTabGroupBackgroundLayout tabGroupBackGroundLayout;

    AknIconConfig::TPreferredDisplayMode mode;

    AknIconConfig::PreferredDisplayMode( mode,

                                         AknIconConfig::EImageTypeOffscreen );

    TDisplayMode bitmapDisplayMode = mode.iBitmapMode;

    TDisplayMode maskDisplayMode   = EGray256;

    TSize size( iTabGroupBackgroundParent.Size() );

    // BITMAP

    tabGroupBackGround.iBitmap = new (ELeave) CFbsBitmap();

    CleanupStack::PushL( tabGroupBackGround.iBitmap );

    User::LeaveIfError( tabGroupBackGround.iBitmap->Create( size, bitmapDisplayMode ) );

    CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL( tabGroupBackGround.iBitmap );

    CleanupStack::PushL( bitmapDevice );

    CFbsBitGc* bitmapGc;

    User::LeaveIfError( bitmapDevice->CreateContext( bitmapGc ) );

    // Clear background first...

    bitmapGc->SetBrushColor( KRgbBlack );

    bitmapGc->SetBrushStyle( CGraphicsContext::ESolidBrush );

    bitmapGc->DrawRect( iTabGroupBackgroundParent );

    bitmapGc->SetBrushStyle( CGraphicsContext::ENullBrush );

    DrawTabGroupBackgroundL( CAknTabGroupGraphics::ENormal,

                             aLongTabs,

                             aNumberOfTabs,

                             aActiveTab,

                             bitmapGc,

                             tabGroupBackGroundLayout,

                             ENone );

    delete bitmapGc;

    CleanupStack::Pop( 2, tabGroupBackGround.iBitmap );

    delete bitmapDevice;

    bitmapGc = NULL;

    bitmapDevice = NULL;

    // MASK

    tabGroupBackGround.iMask = new (ELeave) CFbsBitmap();

    CleanupStack::PushL( tabGroupBackGround.iMask );

    User::LeaveIfError( tabGroupBackGround.iMask->Create( size, maskDisplayMode ) );

    bitmapDevice = CFbsBitmapDevice::NewL( tabGroupBackGround.iMask );

    CleanupStack::PushL( bitmapDevice );

    User::LeaveIfError( bitmapDevice->CreateContext( bitmapGc ) );

    // Clear background first...

    bitmapGc->SetBrushStyle( CGraphicsContext::ESolidBrush );

    if ( maskDisplayMode == EGray256 )

        {

        bitmapGc->SetBrushColor( KRgbBlack );

        }

    else

        {

        bitmapGc->SetBrushColor( KRgbWhite );

        }

    bitmapGc->DrawRect( iTabGroupBackgroundParent );

    bitmapGc->SetBrushStyle( CGraphicsContext::ENullBrush );

    DrawTabGroupBackgroundL( CAknTabGroupGraphics::EMaskOnly,

                             aLongTabs,

                             aNumberOfTabs,

                             aActiveTab,

                             bitmapGc,

                             tabGroupBackGroundLayout,

                             ENone);

    delete bitmapGc;

    CleanupStack::Pop( 2, tabGroupBackGround.iMask );

    delete bitmapDevice;

    return tabGroupBackGround;

    }

#endif

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

// Draws normal tab background from given parameters.

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

//

void CAknTabGroupGraphics::DrawTabGroupBackgroundL(

    TTabDrawMode aTabDrawMode,

    TBool aLongTabs,

    TInt aNumberOfTabs,

    TInt aActiveTab,

    CBitmapContext* aGc,

    SAknTabGroupBackgroundLayout& aLayout,

    TTabsHidden aTabsHidden,

    TTabAnimationType aAnimation ) const

    {

    switch ( aNumberOfTabs )

        {

        case 2:

            {

            if ( aLongTabs )

                {

                DrawTwoLongTabBackground( aTabDrawMode,

                                          aActiveTab,

                                          aGc,

                                          aLayout );

                }

            else

                {

                DrawTwoTabBackground( aTabDrawMode,

                                      aActiveTab,

                                      aGc,

                                      aLayout );

                }

            break;

            }

        case 3:

            {

            if ( aLongTabs )

                {

                DrawThreeLongTabBackground( aTabDrawMode,

                                            aActiveTab,

                                            aGc,

                                            aLayout );

                }

            else

                {

                DrawThreeTabBackground( aTabDrawMode,

                                        aActiveTab,

                                        aGc,

                                        aLayout,

                                        aTabsHidden,

                                        aAnimation );

                }

            break;

            }

        case 4:

            {

            DrawFourTabBackground( aTabDrawMode,

                                   aActiveTab,

                                   aGc,

                                   aLayout );

            break;

            }

        default:

            {

#ifdef AVKON_RDEBUG_ERROR

            RDebug::Print( _L("CAknTabGroupGraphics: Unknown tab layout !") );

#endif

            }

        }

    if ( !aLayout.iUse )

        {

        aLayout.iFirstTab.iActive  = EFalse;

        aLayout.iSecondTab.iActive = EFalse;

        aLayout.iThirdTab.iActive  = EFalse;

        aLayout.iFourthTab.iActive = EFalse;

        if ( aActiveTab == 1 )

            {

            aLayout.iFirstTab.iActive = ETrue;

            }

        else if ( aActiveTab == 2 )

            {

            aLayout.iSecondTab.iActive = ETrue;

            }

        else if ( aActiveTab == 3 )

            {

            aLayout.iThirdTab.iActive = ETrue;

            }

        else if ( aActiveTab == 4 )

            {

            aLayout.iFourthTab.iActive = ETrue;

            }

        }

    }

void CAknTabGroupGraphics::DrawTabGroupNarrowBackgroundL(

    TTabDrawMode aTabDrawMode,

    TBool aLongTabs,

    TInt aNumberOfTabs,

    TInt aActiveTab,

    CBitmapContext* aGc,

    SAknTabGroupBackgroundLayout& aLayout ) const

    {

    switch ( aNumberOfTabs )

        {

        case 2:

            {

            if ( aLongTabs )

                {

                if ( !aLayout.iUse )

                    {

                    aLayout = TwoLongTabNarrowBackground( aActiveTab );

                    }

                aLayout.iUse = ETrue;

                DrawTwoLongTabNarrowBackground( aTabDrawMode,

                                                aActiveTab,

                                                aGc,

                                                aLayout );

                }

            else

                {

                if ( !aLayout.iUse )

                    {

                    aLayout = TwoTabNarrowBackground( aActiveTab );

                    }

                aLayout.iUse = ETrue;

                DrawTwoTabNarrowBackground( aTabDrawMode,

                                            aActiveTab,

                                            aGc,

                                            aLayout );

                }

            break;

            }

        case 3:

            {

            if ( aLongTabs )

                {

                if ( !aLayout.iUse )

                    {

                    aLayout = ThreeLongTabNarrowBackground( aActiveTab );

                    }

                aLayout.iUse = ETrue;

                DrawThreeLongTabNarrowBackground( aTabDrawMode,

                                                  aActiveTab,

                                                  aGc,

                                                  aLayout );

                }

            else

                {

                if ( !aLayout.iUse )

                    {

                    aLayout = ThreeTabNarrowBackground( aActiveTab );

                    }

                aLayout.iUse = ETrue;

                DrawThreeTabNarrowBackground( aTabDrawMode,

                                              aActiveTab,

                                              aGc,

                                              aLayout );

                }

            break;

            }

        case 4:

            {

            if ( !aLayout.iUse )

                {

                aLayout = FourTabNarrowBackground( aActiveTab );

                }

            aLayout.iUse = ETrue;

            DrawFourTabNarrowBackground( aTabDrawMode,

                                         aActiveTab,

                                         aGc,

                                         aLayout );

            break;

            }

        default:

            {

#ifdef AVKON_RDEBUG_ERROR

            RDebug::Print( _L("CAknTabGroupGraphics: Unknown tab layout !") );

#endif

            }

        }

        if ( !aLayout.iUse )

            {

            aLayout.iFirstTab.iActive  = EFalse;

            aLayout.iSecondTab.iActive = EFalse;

            aLayout.iThirdTab.iActive  = EFalse;

            aLayout.iFourthTab.iActive = EFalse;

            if ( aActiveTab == 1 )

                {

                aLayout.iFirstTab.iActive = ETrue;

                }

            else if ( aActiveTab == 2 )

                {

                aLayout.iSecondTab.iActive = ETrue;

                }

            else if ( aActiveTab == 3 )

                {

                aLayout.iThirdTab.iActive = ETrue;

                }

            else if ( aActiveTab == 4 )