/*

* 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:  Implementation of EIKON Menu Pane class (options menu).

*

*/

// INCLUDE FILES

#include <eikmenup.h>

#include <eikmenub.h>

#include <eikmobs.h>

#include <eikon.hrh>

#include <eikpanic.h>

#include <coemain.h>

#include <basched.h>

#include <barsread.h>

#include <eikhkeyt.h>

#include <eikbutb.h>

#include <eikenv.h>

#include <eikcoctl.rsg>

#include <gulcolor.h>

#include <gulutil.h>

#include <eikappui.h>

#include <eiksbfrm.h>

#include <eikscrlb.h>

#include <gulicon.h>

#include <aknborders.h>     // AKNLAF

#include <aknenv.h>

#include <AknUtils.h>

#include <aknpopuplayout.h>

#include <bidi.h>  // Bidirectional support

#include <bidivisual.h>

#include <aknconsts.h>

#include <avkon.mbg>

#include <AknsDrawUtils.h>

#include <AknsFrameBackgroundControlContext.h>

#include <AknBidiTextUtils.h>

#include <skinlayout.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknLayoutFont.h>

#include <AknsUtils.h>

#include <AknIconUtils.h>

#include <aknappui.h>

#include <layoutmetadata.cdl.h>

#include <AknStatuspaneUtils.h>

#include <aknCharMap.h>

#include <gfxtranseffect/gfxtranseffect.h> //For transition effects

#include <akntranseffect.h> //For transition effects

#include <akntransitionutils.h> // SetAllParents method

#include <featmgr.h>

#include <avkondomainpskeys.h>

#include <e32property.h>

#include <touchfeedback.h>

#include <AknTasHook.h>

#include <aknphysics.h>

#include <aknphysicsobserveriface.h>

#include <aknPriv.hrh>

#include "aknitemactionmenudata.h"

#include "akntrace.h"

// CONSTANTS

const TInt KItemGranularity = 4;

const TInt KAlternativeSubmenuWidths = 5; // five alternative widths for submenus depending on max text width

const TInt KNoSelectedRadioButtonItem = -1;

// Delay before opening sub menu when dragging, 0.3s

const TInt KCascadeMenuOpenDelay = 300000;

class CRedirectionListener;

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

// TaskSwapCallBack

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

//

TInt TaskSwapCallBack( TAny* )

    {

    CEikonEnv::Static()->DisplayTaskList();

    return EFalse;

    }

// =============================================================================

// Extension class declaration & definition

// =============================================================================

/*

 * CEikMenuPaneExtension

 *

 * Structure containing extra local private data members.

 * Created to preserve BC.  The CEikMenuPane class contains a pointer to this structure

 * CEikmenuPane is responsible for data members of this class.

 *

 * Extension now contains menu/submenu highlight animation functionality.

 */

NONSHARABLE_CLASS( CEikMenuPaneExtension ):

    public MCoeControlObserver,

    public MAknPhysicsObserver    

    {

public:

    CEikMenuPaneExtension();

    ~CEikMenuPaneExtension();

    void ConstructL( CEikMenuPane* aControl );

    void MenuClosed();

    void ConstructMenuSctRowL( TDes& aSpecialChars, TInt aResourceId );

    void ConstructMenuSctRowFromDialogL( TDes& aSpecialChars, TInt aResourceId );

    void StartCascadeMenuTimerL();

    void StopCascadeMenuTimer();

    static TInt CascadeMenuTimerCallBack( TAny* aThis );

    TBool IsCascadeMenuTimerActive();

    void StartHighlightTimerL();

    void ResetPressedHighlight();

    static TInt HighlightTimerCallBack( TAny* aThis );

    TBool HighlightTimerActive() const;

    void ChangePosition( TPointerEvent& aPointerEvent );

    void CalculateParentEvent( const TPointerEvent& aPointerEvent, 

                               TPointerEvent& aParentEvent );

    void HandleControlEventL(CCoeControl* aControl,TCoeEvent aEventType);

public:

    void ImmediateFeedback( TTouchLogicalFeedback aType,

                            TTouchFeedbackType aFbType );

public:

    void StartCascadeMenuAppearTransition();

    /**

     * Prepares cascade menu for item specific commands.

     */

    void PrepareCascadeForItemCommands();

    /**

     * Returns ETrue if this menu pane belongs to a CS menu.

     * 

     * @return ETrue if this menu pane belongs to a CS menu.

     */

    TBool ContextSensitiveMenu() const;

    /**

     * Returns ETrue if item is item specific command and the command is not

     * dimmed.

     * 

     * @param aItem Menu pane item.

     * @return ETrue if item is item specific command.

     */

    static TBool ItemSpecificCommand( CEikMenuPaneItem& aItem );

    /**

     * Enables or disables highlight

     * 

     * @param aEnabled ETrue to enable highlight, EFalse to disable.

     * @param aPointerEnabled ETrue if highlight was enabled due

     * to a pointer event.

     */

    void EnableHighlight( TBool aEnabled, TBool aPointerEnabled = EFalse );

    /**

     * Is highlight enabled

     * 

     * @return ETrue if highlight is enabled

     */

    /**

     * Sets the default highlight to options menu

     * 

     */    

    void SetDefaultHighlight();

public: // Data

    CFbsBitmap* iCascadeBitmap;

    CFbsBitmap* iCascadeBitmapMask;

    CAknsFrameBackgroundControlContext* iBgContext;

    TInt        iSubMenuWidthIndex;       // index for submenu layout which depends on the text length

    CFbsBitmap* iCheckMarkBitmap;         // bitmap to be drawn if the item has check box set on

    CFbsBitmap* iCheckMarkBitmapMask;     // mask for the above bitmap

    CFbsBitmap* iRadioButtonBitmap;       // bitmap to be drawn if the item has radio button set on

    CFbsBitmap* iRadioButtonBitmapMask;   // mask for the above bitmap

    TBool       iHasRadioGroup;           // is ETrue if submenu contains radio button group.

    TInt        iSelectedRadioButtonItem; // index of the radio button item which is currently selected (one must be selected)

    CEikMenuPane* iControl;

    CAknCharMap* iSct;      // Menu SCT row, created only when needed.

    TBool iSctHighlighted;  // No "normal" menu item can be highlighted if ETrue

    // Pen event related flag indicating whether the (sub)menu pane has

    // already consumed EButton1Down or not. If false,

    // EButton1Up will do nothing.

    TBool iItemsReadyForPenSelection;

    TBool iSpecialCharPointed;

    // transition demarcation rectangle for cascaded submenu

    // needs to be mutable since we need to get information from Draw methods

    // (that are declared const)

    mutable TRect iCascadeDRect;

    TBool iShowCascadeTransition;

    // For later deletion of cascade menu, this allows the transition system

    // to correctly handle the aborted transitions

    CEikMenuPane* iCascadeMenuObject;

    TBool iDraggedOutside;    

    TPointerEvent iLastPointerEvent;

    TInt iItemsThatFitInView;

    TRect iScrollBarRect;

    TRect iSctRect;

    CIdle* iTaskSwapIdle;

    CRedirectionListener* iRedirectionListener;

    RWindow* iMenuPaneWindow; // Not own, used by SCT

    TBool iLaunchCascadeMenu; 

    TBool isUpdateScrollDirectly;

    TBool iPressedDown;      // ETrue if pointer is down, otherwise.

    CEikCba* iCba; // Embedded cba

    TRect iMenuPaneRect; // Menu area of options menu

    TBool iDownOnMenuArea; // Down event received inside menu area

    TBool iDownOnCbaArea; // Down event received inside embedded CBA area

    /**

     * Menu pane extension flags definition.

     */

    enum TCEikMenuPaneExtensionFlags

        {

        ESingleClickEnabled,

        EHideItemSpecificCommands,

        EContextSensitive,

        EHighlightEnabled

        };

    /**

     * Menu pane extension flags.

     */

    TBitFlags iFlags;

private: // Data

    CPeriodic* iTimer; // timer to launch submenu, own

    CPeriodic* iHighlightTimer; // Timer to adjust pressed down highlight

    TInt iVerticalOffset; // Panning offset

public: // MAknPhysicsObserver

    virtual void ViewPositionChanged( const TPoint& aNewPosition,

                                      TBool aDrawNow = ETrue,

                                      TUint aFlags = 0 );

    virtual void PhysicEmulationEnded();    

    virtual TPoint ViewPosition() const;

public:    

    void InitPhysicsL();

    void DoOffset( TInt aOffset );

    void RestoreOffset( TInt aKeyCode );

    void SetOffset( TInt aOffset );

    inline TInt Offset() const { return iVerticalOffset; };

    CAknPhysics *iPhysics; 

    TPoint iViewPosition; // Current view position

    TInt iListTopIndex;

    TInt iListBottomIndex;

    TInt iViewHeight;

    TBool iFlickActive;

    TBool iPanningActive;

    TBool iKeyEventActive;

    // For dragging

    TPoint iStartPoint;

    TTime iStartTime;

    TPoint iPrevPoint;

    // For highlight

    TInt iButtonDownItem; // Item on which down event came

    TInt iNextHighlightItem; // Item waiting for highlight timer

    // When doing a full redraw drawitem should not

    // draw the background because draw has already

    // drawn it.

    TBool iFullRedraw;

    MTouchFeedback* iFeedback;

    // The top item index is stored to this member and used for controlling

    // tactile feedback when panning/flicking (feedback is only given when

    // new item comes into view, i.e. when the top item index changes)

    TInt iLastFeedbackTopItemIndex;

    };

//

// CEikMenuPane::CMenuScroller

//

class CEikMenuPane::CMenuScroller : public CBase, public MEikScrollBarObserver

    {

private:    

    friend class CEikMenuPaneExtension;

public:

    static CMenuScroller* NewL( CEikMenuPane& aMenu );

    ~CMenuScroller();

    inline TInt TopItemIndex() const;

    inline void SetTopItemIndex( TInt aIndex );

    inline CIdle* Idle() const;

public: // from MEikScrollBarObserver

    void HandleScrollEventL( CEikScrollBar* aScrollBar, TEikScrollEvent aEventType );

private:

    CMenuScroller( CEikMenuPane& aMenu );

    void ConstructL();

private:

    CEikMenuPane& iMenuPane;

    TInt iTopItemIndex;

    CIdle* iIdle;

    };

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

// CEikMenuPane::CMenuScroller::NewL

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

//

CEikMenuPane::CMenuScroller* CEikMenuPane::CMenuScroller::NewL( CEikMenuPane& aMenuPane )

    { // static

    CMenuScroller* self = new(ELeave)CMenuScroller( aMenuPane );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CEikMenuPane::CMenuScroller::~CMenuScroller

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

//

CEikMenuPane::CMenuScroller::~CMenuScroller()

    {

    delete iIdle;

    }

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

// CEikMenuPane::CMenuScroller::CMenuScroller

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

//

CEikMenuPane::CMenuScroller::CMenuScroller( CEikMenuPane& aMenuPane )

    : iMenuPane( aMenuPane ), iTopItemIndex( 0 )

    {}

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

// CEikMenuPane::CMenuScroller::ConstructL

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

//

void CEikMenuPane::CMenuScroller::ConstructL()

    {

    iIdle = CIdle::NewL( CActive::EPriorityIdle );

    }

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

// CEikMenuPane::CMenuScroller::HandleScrollEventL

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

//

void CEikMenuPane::CMenuScroller::HandleScrollEventL( CEikScrollBar* aScrollBar,

                                                     TEikScrollEvent aEventType )

    {

    iMenuPane.HandleScrollEventL( aScrollBar, aEventType );

    }

inline TInt CEikMenuPane::CMenuScroller::TopItemIndex() const

    { return iTopItemIndex; }

inline void CEikMenuPane::CMenuScroller::SetTopItemIndex(TInt aIndex)

    { 

    iTopItemIndex=aIndex;

    }

inline CIdle* CEikMenuPane::CMenuScroller::Idle() const

    { return iIdle; }

void CEikMenuPaneExtension::InitPhysicsL()

    {

    _AKNTRACE_FUNC_ENTER;

    iVerticalOffset = 0;

    iListTopIndex = 0;

    iLastFeedbackTopItemIndex = 0;

    iPressedDown = EFalse;

    iFlickActive = EFalse;

    TInt itemHeight = iControl->iItemHeight;

    TInt itemsInRect = rect.Height() / itemHeight;

    TInt totalItemHeight = iControl->TotalItemHeight();

    iViewHeight = itemsInRect * itemHeight;

    TSize totalSize( rect.Width(), totalItemHeight );

    TSize viewSize( rect.Width(), iViewHeight );

    // Using main menu width also for submenu(s), this

    // enables consistent scroll physics between main

    // menu and submenus 

    if ( iControl->iOwner )

        {       

        CEikMenuPane* menu = iControl->iOwner;

        // Go through sub menu hierarchy. There might be

        // multiple submenus, although default case is 

        // only one submenu.

        while ( menu->iOwner )

            {

            CEikMenuPane* prevMenu( menu );

            menu = menu->iOwner;

            // This prevents infinite loop if iOwner is equal to menu.

            if ( menu == prevMenu )

                {

                break;

                }

            }

        totalSize = TSize( menu->Rect().Width(), totalItemHeight );

        viewSize = TSize( menu->Rect().Width(), iViewHeight );      

        }

    iPhysics->InitPhysicsL( totalSize, viewSize, EFalse );

    iViewPosition = TPoint( rect.Width() / 2, iListTopIndex + iViewHeight / 2 );

    _AKNTRACE( "totalSize(%d, %d)", totalSize.iWidth, totalSize.iHeight );

    _AKNTRACE( "viewSize(%d, %d)", viewSize.iWidth, viewSize.iHeight );

    _AKNTRACE( "iViewPosition(%d, %d)", iViewPosition.iX, iViewPosition.iY );

    _AKNTRACE_FUNC_EXIT;

    }

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

// Physics emulation has moved the view.

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

//

void CEikMenuPaneExtension::ViewPositionChanged( const TPoint& aNewPosition,

                                                 TBool aDrawNow,

                                                 TUint /*aFlags*/ )

    _AKNTRACE_FUNC_ENTER;

        {

        return;

        }

    iListTopIndex = aNewPosition.iY - iViewHeight / 2;  

    iListBottomIndex = aNewPosition.iY + iViewHeight - iViewHeight / 2;

    DoOffset( delta );

    iViewPosition = aNewPosition; 

    _AKNTRACE( "iListTopIndex = %d",  iListTopIndex );

    _AKNTRACE( "iListBottomIndex = %d",  iListBottomIndex );

    _AKNTRACE( "delta = %d",  delta );

    _AKNTRACE( "iViewPosition(%d,%d)",  iViewPosition.iX, iViewPosition.iY );

    if ( aDrawNow )

        {

            {

            }

            {

        }

    _AKNTRACE_FUNC_EXIT;

    }

void CEikMenuPaneExtension::DoOffset( TInt aOffset )

    {                                      

    _AKNTRACE_FUNC_ENTER;

    TInt itemsInRect = iControl->NumberOfItemsThatFitInView();

    TInt bottomListPosition = 0;

    if(iControl->iItemArray->Count() > itemsInRect)

        {

        bottomListPosition = (iControl->iItemArray->Count() - itemsInRect) * iControl->iItemHeight;

        }

    TInt itemIndex = iListTopIndex;