/*

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

*

*/

#include <eikmenub.h>

#include <eikmenup.h>

#include <eikmobs.h>

#include <eikhkeyt.h>

#include <eikon.hrh>

#include <barsread.h>

#include <eikenv.h>

#include <eikcmobs.h>

#include <gulutil.h>

#include <eikbtgpc.h>

#include <eikkeys.h>

#include <eikappui.h>

#include <aknappui.h>

#include <aknborders.h>     // AKNLAF

#include <aknenv.h>

#include <AknUtils.h>

#include <gulcolor.h>

#include <gulicon.h>

#include "LAFMENUB.H"

#include "LAFMENUP.H"

#include "eikmop.h"

#include <avkon.rsg>

#include <avkon.hrh>

#include <AknLayout.lag>

#include <aknsoundsystem.h>

#include <AknPopupFader.h>

#include <AiwServiceHandler.h>

#include <gfxtranseffect/gfxtranseffect.h> 

#include <akntranseffect.h>

#include <akntransitionutils.h>

#include "avkoninternalpskeys.h" //KAknMenuOptionNoTaskSwapper

#include <AknCapServerDefs.h>

#include <e32property.h>

#include <AknTasHook.h>

#include <touchfeedback.h>

#include <aknitemactionmenu.h>

#include "aknitemactionmenuregister.h"

#include <AknPriv.hrh>

#include "akntrace.h"

#include "aknmarkingmode.h"

enum { EEikMenuBarTitleArrayGranularity=10 };

enum { EEikMenuBarPosArrayGranularity=2 };

const TInt KExtraBaselineOffsetForFirstPaneItem=4;

NONSHARABLE_CLASS(CEikMenuBarExtension) : public CBase, public MAknFadedComponent

    {

public:

    static CEikMenuBarExtension* NewL(CEikMenuBar* aBar);

    ~CEikMenuBarExtension();

    void FadeBehindPopup(TBool aFade);

    /**

     * Dims item specific commands if no highlight in list or dims

     * other than item specific commands if list is in multiple marking

     * state.

     */

    void SetItemCommandsStateL();

    /**

     * Returns active marking mode object. Otherwise NULL.

     * 

     * @return Active marking mode object.

     */

    CAknMarkingMode* MarkingModeActive();

    /**

     * Saves current value of iItemActionMenu->CollectionHighlightVisible() to 

     * a member variable iCollectionHighlightVisible

     */

    void StoreCollectionHighlightValue(); 

public: // from MAknFadedComponent

    TInt CountFadedComponents();

    CCoeControl* FadedComponent(TInt aIndex);

private:

    CEikMenuBarExtension(CEikMenuBar* aBar);

    void ConstructL();

private:

    CEikMenuBar* iBar;

    TAknPopupFader iFader;

public:

    TInt iContextMenuTitleResourceId;

    TInt iOriginalMenuTitleResourceId;

    CEikMenuBar::TMenuType iMenuType;

    // controls fader and transition aborting behaviour

    // with transition effects

    TBool iDoingMenuCloseTransition;

    /**

     * Item action menu.

     * Not own.

     */

    CAknItemActionMenu* iItemActionMenu;

    /**

     * ETrue if single click has been enabled in application.

     */

    TBool iSingleClickEnabled; 

    /**

     * When menu pane is opened this value is updated to store the value about

     * collection highlight visibility

     */

    TBool iCollectionHighlightVisible; 

    };

CEikMenuBarExtension* CEikMenuBarExtension::NewL(CEikMenuBar* aBar)

    {

    CEikMenuBarExtension* self = new(ELeave) CEikMenuBarExtension(aBar);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CEikMenuBarExtension::~CEikMenuBarExtension()

    {

    AknItemActionMenuRegister::UnregisterMenuBar( *iBar );

    iBar = NULL;

    }

void CEikMenuBarExtension::FadeBehindPopup(TBool aFade)

    {

    _AKNTRACE_FUNC_ENTER;

    _AKNTRACE( "iDoingMenuCloseTransition: %d",  iDoingMenuCloseTransition );

    if( iDoingMenuCloseTransition == EFalse )

        {

        iFader.FadeBehindPopup(this, iBar, aFade);

        }

    _AKNTRACE_FUNC_EXIT;

    }

void CEikMenuBarExtension::SetItemCommandsStateL()

    {

    if ( iSingleClickEnabled && !iItemActionMenu )

        {

        AknItemActionMenuRegister::RegisterMenuBarL( *iBar );

        }

    // Hide item-specific commands if highlight not visible

    // or show only item specific commands if list is in multiple marking

    // state

    if ( iBar->GetMenuType() != CEikMenuBar::EMenuContext )

        {

        if ( iItemActionMenu )

            {

            TBool dimCommands( EFalse );

            TBool changeState( EFalse );

            TBool dimMarkAndUnmark( EFalse ); 

            if ( iItemActionMenu->MarkingMode().MultipleMarkingActive() )

                {

                changeState = ETrue;

                dimCommands = EFalse;

                iBar->iMenuPane->SetItemActionsStateL( ETrue );

                }

            else if ( !iItemActionMenu->CollectionHighlightVisible() )

                {

                if ( iItemActionMenu->CollectionHasMarkedItems() )

                    {

                    TInt pos; 

                    if ( iBar->iMenuPane->MenuItemExists( EAknCmdMark, pos ) ) 

                        {

                        iBar->iMenuPane->SetItemDimmed( EAknCmdMark, ETrue ); 

                        }

                    if ( iBar->iMenuPane->MenuItemExists( EAknCmdUnmark, pos ) ) 

                        {

                        iBar->iMenuPane->SetItemDimmed( EAknCmdUnmark, ETrue ); 

                        } 

                    iBar->iMenuPane->SetItemActionsStateL( ETrue );

                    dimMarkAndUnmark = ETrue; 

                    }

                else 

                    {

                    changeState = ETrue;

                    dimCommands = ETrue;

                    }

                }

            if ( changeState )

                {

                iBar->iMenuPane->SetItemCommandsStateL( dimCommands );

                }

            iBar->iMenuPane->HideMarkAndUnmark( dimMarkAndUnmark ); 

            }

        else if ( iSingleClickEnabled )

            {

            // Dim tagged item action and item specific commands 

            // anyway, fixes case where listbox creation is not 

            // finished yet when options menu is opened

            iBar->iMenuPane->SetItemCommandsStateL( ETrue );

            }

        }

    }

CAknMarkingMode* CEikMenuBarExtension::MarkingModeActive()

    {

    CAknMarkingMode* markingMode( NULL );

    if ( iItemActionMenu

            && iItemActionMenu->MarkingMode().MultipleMarkingActive() )

        {

        markingMode = &iItemActionMenu->MarkingMode();

        }

    return markingMode;

    }

void CEikMenuBarExtension::StoreCollectionHighlightValue()

    {

    if ( iItemActionMenu )

        {

        iCollectionHighlightVisible

                = iItemActionMenu->CollectionHighlightVisible();

        }

    }

CEikMenuBarExtension::CEikMenuBarExtension(CEikMenuBar* aBar)

    :iBar(aBar),

     iDoingMenuCloseTransition(EFalse),

     iItemActionMenu( NULL ),

     iSingleClickEnabled(

             static_cast<CAknAppUi*>(

                     aBar->ControlEnv()->AppUi() )->IsSingleClickCompatible() )

    {

    }

void CEikMenuBarExtension::ConstructL()

    {

    }

TInt CEikMenuBarExtension::CountFadedComponents()

    {

    TInt count = 1; // the cba

    // count the menu pane and it's cascade panes

    CEikMenuPane* pane = iBar->iMenuPane;

    while (pane)

        {

        count++;

        pane = pane->CascadeMenuPane();

        }

    return count;

    }

CCoeControl* CEikMenuBarExtension::FadedComponent(TInt aIndex)

    {

    if (aIndex == 0)

        return iBar->iMenuCba;

    // count down the list of cascade menus to find the one in question

    aIndex--;

    CEikMenuPane* pane = iBar->iMenuPane;

    while (aIndex > 0 && pane != NULL)

        {

        aIndex--;

        pane = pane->CascadeMenuPane();

        }

    return pane;

    }

//

// class CTitleArray

//

EXPORT_C CEikMenuBar::CTitleArray::~CTitleArray()

    {

    ResetAndDestroy();

    }

EXPORT_C CEikMenuBar::CTitleArray::CTitleArray()

    : CArrayPtrFlat<CEikMenuBarTitle>(EEikMenuBarTitleArrayGranularity)

    {

    __DECLARE_NAME(_S("CEikMenuBar::CTitleArray"));

    }

/**

 * Adds the menu bar title aMenuTitle to the end of the array owned by the menu bar

 * and transfers ownership.

 */

EXPORT_C void CEikMenuBar::CTitleArray::AddTitleL(CEikMenuBarTitle* aMenuTitle)

    {

    AppendL(aMenuTitle);

    }

void CEikMenuBar::CTitleArray::DeleteResource(TInt aResource)

    {

    TInt count = Count();

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

        {

        CEikMenuBarTitle* title = At(ii);

        if (title->iData.iMenuPaneResourceId == aResource)

            {

            delete title;

            Delete(ii);

            return;

            }

        }

    }

//

// class CEikMenuBarTitle

//

//const TInt KTitleGranularity=1;

//const TInt KIconOwnedExternally       = 0x01;

//const TInt KSameBitmapAndMask     = 0x10;

//const TInt KTitleWithImageMask        = 0xf000;

EXPORT_C CEikMenuBarTitle::CEikMenuBarTitle()

    {}

EXPORT_C CEikMenuBarTitle::~CEikMenuBarTitle()

    {

    delete iIcon;

    }

EXPORT_C void CEikMenuBarTitle::SetIcon(CGulIcon* aIcon)

    {

    if (iIcon)

        delete iIcon;

    iIcon = aIcon;

    }

/**

 * Returns the value of the extra left margin for the title text which will take into account the

 * width of the title icon.

 */

TInt CEikMenuBarTitle::ExtraLeftMargin() const

    {

    CFbsBitmap* bitmap = IconBitmap();

    TInt extraMargin = 0;

    if (bitmap != NULL)

        extraMargin = bitmap->SizeInPixels().iWidth;

    return extraMargin;

    }

/**

 * Adjusts the value of the title text baseline offset aBaseLine to take into account the any

 * size of any title icon.

 */

void CEikMenuBarTitle::CalculateBaseLine(TInt& aBaseLine, TInt& aTitleHeight)

    {

    CFbsBitmap* bitmap = IconBitmap();

    if (bitmap != NULL)

        {

        TInt tempBaseline = aBaseLine;

        const TSize bitmapSize(bitmap->SizeInPixels());

        if (bitmapSize.iHeight > aTitleHeight)

            {

            tempBaseline += ((bitmapSize.iHeight - aTitleHeight) >> 1);

            aTitleHeight = bitmapSize.iHeight; 

            }

        if (tempBaseline > aBaseLine)

            aBaseLine = tempBaseline;

        }

    }

/**

 * Draws the title icon to the graphics context aGc, inside the rect aRect with an offset from the left side of

 * the rectangle of size aLeftMargin

 */

EXPORT_C void CEikMenuBarTitle::DrawIcon(CWindowGc& aGc, TRect aRect, TInt aLeftMargin) const

    {

    CFbsBitmap* bitmap = IconBitmap();

    if (bitmap != NULL)

        {

        TSize imageSize = bitmap->SizeInPixels();

        aRect.iTl.iX += aLeftMargin;

        TInt height = aRect.iBr.iY - aRect.iTl.iY;

        if (height > imageSize.iHeight)

            aRect.iTl.iY += (TInt) ((height - imageSize.iHeight) / 2 );

        aGc.BitBltMasked(aRect.iTl, bitmap, imageSize, IconMask(), ETrue);

        }

    }

/**

 * Sets the title icon to be ownded externally if aOwnedExternally is ETrue.

 */

EXPORT_C void CEikMenuBarTitle::SetBitmapsOwnedExternally(TBool aOwnedExternally)

    {

    iIcon->SetBitmapsOwnedExternally(aOwnedExternally);

    }

/**

 * Returns a pointer to the picture bitmap of the title icon.

 * Does not normally imply transfer of ownership.

 */

EXPORT_C CFbsBitmap* CEikMenuBarTitle::IconBitmap() const

    {

    if (iIcon)

        return iIcon->Bitmap();

    return NULL;

    }

/**

 * Returns a pointer to the mask bitmap of the title icon.

 * Does not normally imply transfer of ownership.

 */

EXPORT_C CFbsBitmap* CEikMenuBarTitle::IconMask() const

    {

    if (iIcon)

        return iIcon->Mask();

    return NULL;

    }

/**

 * Sets the picture bitmap for the title icon to aBitmap.

 * Transfers ownership unless the bitmaps are owned externally.

 */

EXPORT_C void CEikMenuBarTitle::SetIconBitmapL(CFbsBitmap* aBitmap)

    {

    if (!iIcon)

        iIcon=CGulIcon::NewL();

    iIcon->SetBitmap(aBitmap);

    }

/**

 * Sets the mask bitmap for the title icon to aMask.

 * Transfers ownership unless the bitmaps are owned externally.

 */

EXPORT_C void CEikMenuBarTitle::SetIconMaskL(CFbsBitmap* aMask)

    {

    if (!iIcon)

        iIcon=CGulIcon::NewL();

    iIcon->SetMask(aMask);

    }

/**

 * Constructs an new icon for the title, taking ownership of the picture bitmap

 * aBitmap and the mask bitmap aMask unless the icon bitmaps have been set to be

 * owned externally.

 */

EXPORT_C void CEikMenuBarTitle::CreateIconL(CFbsBitmap* aBitmap, CFbsBitmap* aMask)

    {

    if (iIcon)

        delete iIcon;

    iIcon = CGulIcon::NewL(aBitmap, aMask);

    }

//

// class CEikMenuBar

//

//const TInt KEikMenuBarHBorder=8;

//const TInt KEikMenuBarVBorder=2;

//const TInt KEikMenuMnenPad=3;

//const TInt KEikMaxMenuTitlePadding=10;

//const TInt KEikNumOfSideButtons=5;

//const TInt KEikSidebarPopupXPos=5;

//const TInt KMenuPaneOverlap=1;

//const TInt KMenuTitleLeftSpace = 12;

//const TInt KMenuTitleRightSpace = 12;

//const TInt KMenuTitleLeftSmallSpace = 2;

//const TInt KMenuTitleRightSmallSpace = 2;

inline TBool CEikMenuBar::MenuHasItems() const

    {

    return iMenuFlags&EMenuHasItems;

    }

inline void CEikMenuBar::SetMenuHasItems()

    {

    iMenuFlags|=EMenuHasItems;

    }

inline TBool CEikMenuBar::MenuHasPane() const

    {

    return iMenuFlags&EMenuHasPane;

    }

inline void CEikMenuBar::SetMenuHasPane()

    {

    iMenuFlags|=EMenuHasPane;

    }

inline TBool CEikMenuBar::TitleArrayOwnedExternally() const

    {

    return iMenuFlags&ETitleArrayOwnedExternally;

    }