/*

* Copyright (c) 2002-2009 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:  Command button array implementation.

*

*/

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <uikon/eikdefmacros.h>

#endif

#include <barsread.h>

#include "eikcba.h"

#include <eiklabel.h>

#include <eiksoftkeyimage.h>

#include <eiksoftkeypostingtransparency.h>

#include <eikbtgpc.h>

#include <aknappui.h>

#include <AknUtils.h> // LayoutUtils

#include <aknlayoutscalable_apps.cdl.h>

#include <AknsBasicBackgroundControlContext.h>

#include <AknsMaskedLayerBackgroundControlContext.h>

#include <AknsDrawUtils.h>

#include <AknsConstants.h>

#include <aknconsts.h>

#include <AknSgcc.h>

#include <AknStatuspaneUtils.h>

#include <aknpriv.rsg> // R_ENHANCED_CBA_PRIORITIES

#include <aknlayoutscalable_avkon.cdl.h>

#include <layoutmetadata.cdl.h>

#include <avkon.mbg>

#include <centralrepository.h>

#include <AvkonInternalCRKeys.h>  // KAknMiddleSoftkeyEnabled

#include <cenrepnotifyhandler.h>

#include <AknSkinsInternalCRKeys.h>

#include <aknQueryControl.h>

#include <aknbutton.h>

#include <akniconconfig.h>

#include <akncommandbuttonstate.h>

#include <AknTasHook.h>

#include <akncbacontentobserver.h>

#include <aknitemactionmenu.h>

#include "akncollectionobserver.h"

#include "aknitemactionmenuregister.h"

/**

 * Color value for transparent pixel (ARGB format).

 */

const TUint32 KAknCbaColorKey = 0x00000000;

/**

 * Mask for opaque pixel (ARGB format).

 */

const TUint32 KAknCbaOpaqueMask = 0xFF000000;

/**

 * Mask for outline font in font id.

 */

const TUint32 KOutlineFontMask = 0x00000040;

#include <touchfeedback.h>

inline TAknWindowComponentLayout DoCompose(TAknWindowComponentLayout aLine1, 

    TAknWindowComponentLayout aLine2) 

    { 

    return TAknWindowComponentLayout::Compose(aLine1, aLine2); 

    }

inline TAknTextComponentLayout DoComposeText(TAknWindowComponentLayout aLine1, 

    TAknTextComponentLayout aLine2) 

    { 

    return TAknWindowComponentLayout::ComposeText(aLine1, aLine2); 

    }

/**

* Checks if right side pane is active.

* @return ETrue if right side pane is active, EFalse otherwise.

*/

static TBool IsAreaSideRightPaneActive()

    {

    return EFalse;

    }

/**

* Checks if MSK-enabled layout is in use.

*/

static TBool IsMskEnabledLayoutActive()

    {

    TBool result( EFalse );

    if ( Layout_Meta_Data::IsMSKEnabled() )

        {

        // First check if MSK is enabled in the layout metadata.

        result = ETrue;

        }

    else

        {

        TInt statusPaneLayout(

            AVKONENV->StatusPaneResIdForCurrentLayout(

                 AknStatuspaneUtils::CurrentStatusPaneLayoutResId() ) );

        if ( statusPaneLayout ==

                 R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE_FLAT_NO_SOFTKEYS ||

             ( statusPaneLayout == R_AVKON_STATUS_PANE_LAYOUT_IDLE_FLAT &&

               AknLayoutUtils::PenEnabled() &&

               !Layout_Meta_Data::IsLandscapeOrientation() ) )

            {

            // MSK is not enabled in the layout metadata, but for

            // these status pane layouts an exception is made.

            result = ETrue;

            }

        }

    return result;

    }

/*

 * Checks if bitmap must be updated, i.e. bitmap does not exist or 

 * expected size does not match with actual size.

 */

static TBool IsBitmapUpdateNeeded( CFbsBitmap* aOldBitmap, const TSize& aSize )

    {

    return !aOldBitmap || ( aOldBitmap->SizeInPixels() != aSize );

    }

/**

 * Implementation of class CEikCba - Control button array.

 */

const TInt KNoResource                        = 0;

const TInt KMaxSeries60Softkeys               = 3; // 3 softkeys for S60 with MSK

const TInt KControlArrayCBAButton1Posn        = 0;

const TInt KControlArrayScrollBarPosn         = 1;

const TInt KControlArrayCBAButton2Posn        = 2;

const TInt KControlArrayCBAButtonMSKPosn      = 3;

const TInt KCbaScrollBarButtonWidth           = 9;  // in pixels

/** Alpha value used in drawing CBA button contents in pressed down state. */

const TInt KPressedDownAlphaValue             = 127;

/**

* Local panic definitions.

*/

enum TEikPanicCBA

    {

    EEikPanicCBAControlArraySize,

    EEikPanicCBANullButton,

    EEikPanicCBACannotConvertToCEikCommandButton,

    EEikPanicCBAIsNotEnhancedCba,

    EEikPanicCBAButtonCountDiffersFromCommandTableSize

    };

/**

* Local AknLayout definintions.

*/

enum TAknLayoutFlags

    {

    EAknLayoutCbaInControlPane     = 0x1,

    EAknLayoutCbaInStaconPane      = 0x2,

    EAknLayoutCbaInStaconPaneRight = 0x4,

    EAknLayoutCbaInStaconPaneLeft  = 0x8,

    EAknLayoutCbaInStaconPaneIdle  = 0x10,

    EAknLayoutCbaInRightPane       = 0x20

    };

/**

* Enumeration for CEikCommandTable for fetching commands.

*/

enum TCommandTableCbaPositions

    {

    ECommandTableCommand1Posn = 0,

    ECommandTableCommand2Posn = 1,

    ECommandTableCommand3Posn = 2,

    ECommandTableCommand4Posn = 3

    };

enum TCbaChangeRecordedFlags

    {

    ECbaChangeRecordedLayout,

    ECbaChangeRecordedSkin,

    ECbaChangeRecordedColor,

    ECbaInsideDialog,

    ECbaEmbedded,       // cba is embedded in a parent control (dialog or popup)

    ECbaHasContent,     // cba has content and should be visible when embedded

    ECbaParentAsControl, // cba's parent window group is treated as CCoeControl

    ECbaActivationDelayed, // activation delayed

    ECbaSingleClickEnabled, // single click enabled in appUi

    ECbaItemSoftkeyDisabled, // item specific softkey disabled

    ECbaItemSpecificSoftkeyInUse, // item specific softkey is in use

    ECbaItemSoftkeyDisabledByClient // client has disabled item specific softkey

    };

enum TCbaLayers

    {

    ECbaLayerWallpaper,

    ECbaLayerBackground,

    ECbaLayerN

    };

/**

* Local panic routine.

*/

#if defined(_DEBUG)

LOCAL_C void Panic(TEikPanicCBA aPanic)

    {

    _LIT(KPanicCat,"CBA");

    User::Panic(KPanicCat, aPanic);

    }

#endif

/** 

* Internal extension class.

*/

class CEikCbaExtension : public CBase,

                         public MCenRepNotifyHandlerCallback,

                         public MAknCollectionObserver

    {

public:

    CEikCbaExtension( CEikCba& aOwner ) : iOwner( aOwner ), 

                                          iCbaBgIIDSetExt( EFalse )

                                          ,iLeftFrameMask( NULL ),

                                          iRightFrameMask( NULL ),

                                          iItemActionMenu( NULL )

        {

        };

    static CEikCbaExtension* NewL( CEikCba& aOwner )

        {

        CEikCbaExtension* self = new (ELeave) CEikCbaExtension( aOwner );

        CleanupStack::PushL( self );

        self->ConstructL();

        CleanupStack::Pop( self );

        return self;

        }

    void ConstructL() 

        {

        // Wallpaper is not drawn by embedded CBA.

        if ( !iOwner.Flags().IsSet( ECbaEmbedded ) )

            {

            iRepository = CRepository::NewL( KCRUidPersonalisation );

            iRepository->Get( KPslnWallpaperType, iWallpaperInUse );

            iCRListener = CCenRepNotifyHandler::NewL( *this,

                                                  *iRepository,

                                                  CCenRepNotifyHandler::EIntKey,

                                                  KPslnWallpaperType );

            iCRListener->StartListeningL();

            }

        iBackgroundMaskID = KAknsIIDNone;

        iCbaRect = TRect( 0,0,0,0 );

        iIfSkinChanged = EFalse;

        iIfMskIconSet = EFalse;

        iSemiBgID = KAknsIIDNone;

        if ( iOwner.Flags().IsSet( ECbaSingleClickEnabled ) )

            {

            AknItemActionMenuRegister::RegisterCollectionObserverL(

                    *this );

            }

        }

    ~CEikCbaExtension() 

        {

        if ( iOwner.Flags().IsSet( ECbaSingleClickEnabled ) )

            {

            AknItemActionMenuRegister::UnregisterCollectionObserver( *this );

            }

        if ( iCRListener )

            {

            iCRListener->StopListening();

            delete iCRListener;

            }

        delete iRepository;

        delete iPressedMSKFrameBitmap;

        delete iLeftFrameMask;

        delete iRightFrameMask;    

        delete iLskPostingOverlayBitmap;

        delete iRskPostingOverlayBitmap;

        delete iBmpFile;

        }

    /** From base class MCenRepNotifyHandlerCallback */

    void HandleNotifyInt( TUint32 /*aId*/, TInt aNewValue )

        {

        iWallpaperInUse = aNewValue;

        iOwner.SetSkinBackgroundId( KAknsIIDNone );

        }

    void UpdateSoftkeyFrameL( TBool aForcedUpdate )

        {

        if ( !AknLayoutUtils::PenEnabled() )

            {

            return;

            }

        TAknLayoutRect cbarect;

        TRect screen;

        AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, screen );

        TAknWindowComponentLayout applicationWindow(

            AknLayoutScalable_Avkon::application_window( 0 ) );

        TRect innerRect;

        TRect outerRect;

        TRect mskOuterRect;

        TRect mskInnerRect;

        if ( iOwner.Flags().IsSet( ECbaEmbedded ) )

            {

            TRect rect ( iOwner.Rect() );

            if ( rect.Width() > 0 && rect.Height() > 0 )

                {

                TAknLayoutRect layoutRect;

                layoutRect.LayoutRect(

                        rect, 

                        AknLayoutScalable_Avkon::popup_sk_window_g1( 0 ) );                    

                TInt margin = layoutRect.Rect().iTl.iX - rect.iTl.iX;

                TInt buttonWidth = ( rect.Width() - margin * 2 ) / 2;

                outerRect = TRect( 0, 0, buttonWidth, 

                                   layoutRect.Rect().Height() );

                layoutRect.LayoutRect( outerRect,

                     AknLayoutScalable_Avkon::bg_sctrl_sk_pane_g1()

                        .LayoutLine() );

                innerRect = layoutRect.Rect();

                MAknsSkinInstance* skin = AknsUtils::SkinInstance();

                const TSize maskSize = outerRect.Size();

                if (skin && ( aForcedUpdate || IsBitmapUpdateNeeded( iLeftFrameMask, maskSize )

                    || IsBitmapUpdateNeeded( iRightFrameMask, maskSize ) ) )

                    {

                    delete iLeftFrameMask;

                    iLeftFrameMask = NULL;

                    delete iRightFrameMask;

                    iRightFrameMask = NULL;

                    }

                }

            }

        else

            {

            TBool rightPaneActive( IsAreaSideRightPaneActive() );

            TBool bskLandscape( Layout_Meta_Data::IsLandscapeOrientation() &&

                                !rightPaneActive );

            if ( rightPaneActive )

                {

                cbarect.LayoutRect(

                    screen,

                    DoCompose(

                        applicationWindow,

                        AknLayoutScalable_Avkon::area_side_right_pane( 0 ) ).LayoutLine() );

                }

            else

                {            

                cbarect.LayoutRect(

                    screen,

                    DoCompose(

                        applicationWindow,

                        DoCompose(

                            AknLayoutScalable_Avkon::area_bottom_pane( bskLandscape ? 2 : 1 ),

                            AknLayoutScalable_Avkon::control_pane() ) ).LayoutLine() );

                }

            TRect cbaRect( cbarect.Rect() );

            TBool mskEnabled( IsMskEnabledLayoutActive() );

            TAknWindowComponentLayout frameLayout;

            if ( rightPaneActive )

                {

                frameLayout = AknLayoutScalable_Avkon::sctrl_sk_top_pane();

                }

            else if ( bskLandscape || mskEnabled )

                {

                frameLayout = AknLayoutScalable_Avkon::control_pane_g6( 0 );

                }

            else

                {

                frameLayout = AknLayoutScalable_Avkon::bg_sctrl_sk_pane_cp1();

                }

            cbarect.LayoutRect( cbaRect, frameLayout );

            outerRect.SetRect( TPoint( 0, 0 ), cbarect.Rect().Size() );

            if ( mskEnabled )

                {

                cbarect.LayoutRect(

                    cbaRect,

                    AknLayoutScalable_Avkon::control_pane_g7( 0 ) );

                mskOuterRect.SetRect( TPoint( 0, 0 ), cbarect.Rect().Size() );

                }

            else

                {

                iUpdateMSKFrameOuterRect.SetRect( 0, 0, 0, 0 );

                }

            TAknLayoutRect layoutRect;

            layoutRect.LayoutRect(

                outerRect,

                AknLayoutScalable_Avkon::bg_sctrl_sk_pane_g1().LayoutLine() );

            innerRect = layoutRect.Rect();

            if ( mskEnabled )

                {

                layoutRect.LayoutRect(

                    mskOuterRect,

                    AknLayoutScalable_Avkon::bg_sctrl_sk_pane_g1() );

                mskInnerRect = layoutRect.Rect();

                }

            }

        iUpdateFrameOuterRect = outerRect;

        iUpdateFrameInnerRect = innerRect;

        iUpdateMSKFrameOuterRect = mskOuterRect;

        iUpdateMskFrameInnerRect = mskInnerRect;

        }

    /**

     * Merges mask into color bitmap.

     * @internal

     * @since S60 v5.0

     * @param aMask mask to be merged.

     * @param aDestBitmap bitmap to merge mask with.

     */

    static void MergeMaskInto16MA( CFbsBitmap* aMask, CFbsBitmap* aDestBitmap )

        {

        // aMask display mode must be EGray256.

        // aMask must not be compressed in RAM.

        // aDestBitmap display mode must be EColor16MA.

        // aDestBitmap must not be compressed in RAM.

        // aMask size must equal to aDestBitmap size.

        // See UpdatePostingOverlayBitmapL.

        TSize size = aMask->SizeInPixels();

        TUint32 pitch = CFbsBitmap::ScanLineLength( size.iWidth, EGray256 );

        TUint32 destPitch = CFbsBitmap::ScanLineLength( size.iWidth, EColor16MA ) / 4;

        aMask->LockHeap();

        aDestBitmap->LockHeap();

        TUint8* dataAddr = 

            reinterpret_cast<TUint8*>( aMask->DataAddress() );

        TUint32* destAddr = 

            reinterpret_cast<TUint32*>( aDestBitmap->DataAddress() );

        for ( TUint32 y = 0; y < size.iHeight; y++ )

            {

            for ( TUint32 x = 0; x < size.iWidth; x++ )

                {

                TUint8 value = (TUint8)dataAddr[ y * pitch + x ];

                // Round mask value to fully opaque or transparent

                if ( value > 0x7f )

                    {

                    // Opaque pixel.

                    destAddr[ y * destPitch + x ] |= KAknCbaOpaqueMask;

                    }

                else

                    {

                    // Transparent pixel

                    destAddr[ y * destPitch + x ] = KAknCbaColorKey;

                    }

                }

            }

        aDestBitmap->UnlockHeap();

        aMask->UnlockHeap();

        }

    /**

     * Updates posting overlay bitmap.

     * @internal

     * @since S60 v5.0

     * @param aBitmap Reference to bitmap pointer to get the new bitmap.

     * @param aRect Rectangle for the CBA button.

     * @param aControl CEikCba control.

     * @param aButton CEikCbaButton control for the button.

     */

    void UpdatePostingOverlayBitmapL(

            CFbsBitmap*& aBitmap,

            const TRect& aRect,

            CEikCbaButton* aButton )

        {

        delete aBitmap;

        aBitmap = NULL;

        // If you modify this method, please make sure that assumptions

        // mentioned in MergeMaskInto16MA still hold.

        CFbsBitmap* bitmap = new ( ELeave ) CFbsBitmap();

        CleanupStack::PushL( bitmap );

        User::LeaveIfError( bitmap->Create( aRect.Size(), EColor16MA ) );

        CFbsBitGc* bitmapContext = NULL;

        CFbsBitmapDevice* bitmapDevice =

            CFbsBitmapDevice::NewL( bitmap );

        CleanupStack::PushL( bitmapDevice );

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

        CleanupStack::PushL( bitmapContext );

        // Zero alpha channel to make bitmap fully transparent

        bitmapContext->SetDrawMode( CGraphicsContext::EDrawModeWriteAlpha );

        bitmapContext->SetBrushColor( TRgb::Color16MA( 0 ) );

        bitmapContext->Clear();