/*

* Copyright (c) 2005-2010 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:  Content that is shown inside a stylus popup menu.

*

*/

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknsEffectAnim.h>

#include <AknsDrawUtils.h>

#include <AknsFrameBackgroundControlContext.h>

#include <AknBidiTextUtils.h>

#include <AknUtils.h>

#include <AknsConstants.h>

#include <eikapp.h>

#include <aknappui.h>

#include <AknDef.h>

#include <touchfeedback.h>

#include <layoutmetadata.cdl.h>

#include "aknstyluspopupmenuphysicshandler.h"

#include "aknstyluspopupmenucontent.h"

const TInt KItemArrayGranularity = 4;

// Item shown or dimmed

const TInt KShown = 0; 

const TInt KHidden = 1; 

const TInt KNoItemSelected = -1; 

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

// Item class declaration & definition

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

//

NONSHARABLE_CLASS( CAknStylusPopUpMenuItem ) : public CBase

    {

    public:

        CAknStylusPopUpMenuItem( TInt aCommandId );

        ~CAknStylusPopUpMenuItem();

        void ConstructL(const TDesC& aText); 

    public: //Data

        TInt iCommandId; 

        TInt iVisibility;

        HBufC* iText;

        TRect iRect;   

    }; 

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

// CAknStylusPopUpMenuItem::CAknStylusPopUpMenuItem

// Default constructor

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

//

CAknStylusPopUpMenuItem::CAknStylusPopUpMenuItem( TInt aCommandId): 

    iCommandId( aCommandId ), iVisibility( KShown )

    {

    }

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

// CAknStylusPopUpMenuItem::CAknStylusPopUpMenuItem

// Destructor

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

//

CAknStylusPopUpMenuItem::~CAknStylusPopUpMenuItem()

    {

    delete iText; 

    }

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

// CAknStylusPopUpMenuItem::CAknStylusPopUpMenuItem

// Default constructor

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

//

void CAknStylusPopUpMenuItem::ConstructL(const TDesC& aText)

    {

    delete iText;

    iText = NULL; 

    iText = aText.AllocL(); 

    }

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

// Extension class declaration & definition

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

/*

 * Extension contains menu highlight animation functionality. 

 * The CAknStylusPopUpMenuContent class contains a pointer to 

 * this structure. 

 */

NONSHARABLE_CLASS( CAknStylusPopUpMenuExtension ):

    public CActive,

    public MAknsEffectAnimObserver

    {

public:

    enum TFlag

        {

        /**

        * If set, animation creation is attempted. If not set, animation will

        * never be created.

        */

        EFlagUseAnimation = 0

        };

    CAknStylusPopUpMenuExtension();

    ~CAknStylusPopUpMenuExtension();

    void ConstructL( CAknStylusPopUpMenuContent* aControl );

    TInt CreateAnimation();

    void HandleLayoutSwitch();

    void ChangeHighlightBackground();

    void MenuClosed();

public: // Implementation of MAknsEffectAnimObserver

    void AnimFrameReady( TInt aError, TInt );

protected: // CActive overloads

    void DoCancel();

    void RunL();

private: // New internal methods

    void NoAnimIfError( TInt aError );

    void UseNoAnimation();

    void Play();

    TBool DrawHighlightBackground( CFbsBitGc& aGc );

    void PostDeleteAnimation();

    void CreateAnimationL( const TSize& aHighlightSize );

    void DoResizeL( const TSize& aHighlightSize, TBool aAboutToStart );

public: // Data

    CAknsEffectAnim* iAnimation;

    /**

    * Stored flags are explained in enumeration TFlags.

    */

    TBitFlags32 iAnimFlags; 

    TBool iObserverInformed; 

    TBool iInformObserver; 

private: //Data    

    CAknStylusPopUpMenuContent* iControl;

    };

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

// CAknStylusPopUpMenuExtension::CAknStylusPopUpMenuExtension

// High CActive priority is well argumented because running the active object

// will result in animation deletion -> results in freeing resources.

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

//

CAknStylusPopUpMenuExtension::CAknStylusPopUpMenuExtension() :

    CActive( EPriorityHigh ),

    iAnimFlags ( 0 )

    {

    }

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

// CAknStylusPopUpMenuExtension::~CAknStylusPopUpMenuExtension

// Destructor for extension class

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

//

CAknStylusPopUpMenuExtension::~CAknStylusPopUpMenuExtension()

    {

    Cancel(); // Cancel possibly pending request

    delete iAnimation;

    }

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

// CAknStylusPopUpMenuExtension::ConstructL

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

//

void CAknStylusPopUpMenuExtension::ConstructL( CAknStylusPopUpMenuContent* aControl )

    {

    ASSERT( aControl );

    iControl = aControl;

    iAnimFlags.Set( EFlagUseAnimation ); // Animations are created by default

    CActiveScheduler::Add( this );

    }

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

// CAknStylusPopUpMenuExtension::CreateAnimation

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

//

TInt CAknStylusPopUpMenuExtension::CreateAnimation()

    {

    if( !iAnimation && iAnimFlags.IsSet( EFlagUseAnimation ) )

        {

        TRAPD( err, CreateAnimationL( iControl->HighlightRect().Size() ) );

        if( KErrNone != err )

            {

            // Animation has not been drawn -> no need for repaint

            UseNoAnimation();

            return err; 

            }

        }

    return KErrNone; 

    }

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

// CAknStylusPopUpMenuExtension::NoAnimIfError

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

//

void CAknStylusPopUpMenuExtension::NoAnimIfError( TInt aError )

    {

    if( KErrNone != aError )

        {

        UseNoAnimation();

        }

    }

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

// CAknStylusPopUpMenuExtension::UseNoAnimation

// Falls back to normal highlight rendering.

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

//

void CAknStylusPopUpMenuExtension::UseNoAnimation()

    {

    delete iAnimation;

    iAnimation = NULL;

    // Do not attempt to create animations in the future

    iAnimFlags.Clear( EFlagUseAnimation );

    }

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

// CAknStylusPopUpMenuExtension::HandleLayoutSwitch

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

//

void CAknStylusPopUpMenuExtension::HandleLayoutSwitch()

    {

    if( iAnimation ) // Animation exists -> try to resize

        {

        // Resize animation

        TBool aboutToStart = ETrue;

        if( iAnimation->State() == EAknsAnimStateStopped )

            {

            aboutToStart = EFalse;

            }

        TRAPD( err, DoResizeL( iControl->HighlightRect().Size(), aboutToStart ) );

        NoAnimIfError( err );

        }

    }

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

// CAknStylusPopUpMenuExtension::ChangeHighlightBackground

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

//

void CAknStylusPopUpMenuExtension::ChangeHighlightBackground()

    {

    // Every time the current menu item is changed we need to change the

    // animation input layer (animated element is the highlight background that

    // can differ between highlight positions).

    if( iAnimation )

        {

        if( iAnimation->State() == EAknsAnimStateStopped  )

            {

            // Input layers don't exist when stopped or finished. We need to

            // resize to create the input layers and to update the output

            // layer.

            TRAPD( err, DoResizeL( iAnimation->Size(), EFalse ) );

            NoAnimIfError( err );

            }

        else // Either paused, running or finished

            {

            // Update the highlight background

            if( iAnimation->InputRgbGc() )

                {

                DrawHighlightBackground( *iAnimation->InputRgbGc() );

                }

            // We need to update the output frame (otherwise the highlight

            // would be drawn with the old output before the next new animation

            // frame).

            NoAnimIfError( iAnimation->UpdateOutput() );

            }

        }

    }

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

// CAknStylusPopUpMenuExtension::MenuClosed

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

//

void CAknStylusPopUpMenuExtension::MenuClosed()

    {

    delete iAnimation;

    iAnimation = NULL;

    iAnimFlags.Set( EFlagUseAnimation );

    }

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

// CAknStylusPopUpMenuExtension::AnimFrameReady

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

//

void CAknStylusPopUpMenuExtension::AnimFrameReady( TInt aError, TInt )

    {

    if( KErrNone != aError )

        {

        // Animation has failed to run -> schedule the animation for

        // deletion to fall back to normal rendering.

        PostDeleteAnimation();

        }

    else if( iControl ) // Frame ok

        {

        if ( iControl->IsVisible() )

            {

            iControl->RepaintHighlight();

            }

        }

    }

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

// CAknStylusPopUpMenuExtension::DoCancel

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

//

void CAknStylusPopUpMenuExtension::DoCancel()

    {

    // Required method, but not needed

    }

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

// CAknStylusPopUpMenuExtension::RunL

// Postponed animation deletion is done here

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

//

void CAknStylusPopUpMenuExtension::RunL()

    {

    UseNoAnimation();

    }

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

// CAknStylusPopUpMenuExtension::Play

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

//

void CAknStylusPopUpMenuExtension::Play()

    {

    if( !iAnimation )

        {

        return;

        }

    // No need to start running/finished animation

    if( EAknsAnimStateRunning == iAnimation->State() ||

        EAknsAnimStateFinished == iAnimation->State() )

        {

        return;

        }

    if( EAknsAnimStatePaused == iAnimation->State() )

        {

        NoAnimIfError( iAnimation->Continue() );

        }

    else if( EAknsAnimStateStopped == iAnimation->State() )

        {

        if( iAnimation->NeedsInputLayer() )

            {

            TRAPD( err, DoResizeL( iAnimation->Size(), ETrue ) );

            NoAnimIfError( err );

            if( KErrNone != err )

                return;

            }

        NoAnimIfError( iAnimation->Start() );

        }

    }

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

// CAknStylusPopUpMenuExtension::DrawHighlightBackground

// Draws skinned highlight background to the provided graphics context.

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

//

TBool CAknStylusPopUpMenuExtension::DrawHighlightBackground( CFbsBitGc& aGc )

    {

    // Draw the background under the current highlight. This simplified

    // drawing, we only grab a piece from the menu background bitmap.

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    MAknsControlContext *cc = AknsDrawUtils::ControlContext( iControl );

    return AknsDrawUtils::DrawBackground( skin, cc, iControl, aGc, TPoint(0,0),

                                          iControl->HighlightRect(),

                                          KAknsDrawParamRGBOnly );

    }

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

// CAknStylusPopUpMenuExtension::PostDeleteAnimation

// Schedules the animation for deletion by activating the extension itself.

// Deletion is postponed because in many error/failure occasions the caller has

// been animation and direct deletion is possibly not safe (because function

// stack would return through the deleted object).

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

//

void CAknStylusPopUpMenuExtension::PostDeleteAnimation()

    {

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    SetActive();

    }

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

// CAknStylusPopUpMenuExtension::CreateAnimationL

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

//

void CAknStylusPopUpMenuExtension::CreateAnimationL( const TSize& aHighlightSize )

    {

    delete iAnimation;

    iAnimation = NULL;

    iAnimation = CAknsEffectAnim::NewL( this );

    if( !iAnimation->ConstructFromSkinL( KAknsIIDQsnAnimList ) ) 

        {

        // Animation for the ID was not found from the skin

        User::Leave( KErrNotFound );

        }

    DoResizeL( aHighlightSize, ETrue );

    Play();

    }

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

// CAknStylusPopUpMenuExtension::DoResizeL

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

//

void CAknStylusPopUpMenuExtension::DoResizeL(

    const TSize& aHighlightSize, TBool aAboutToStart )

    {

    iAnimation->BeginConfigInputLayersL( aHighlightSize, aAboutToStart );

    if( iAnimation->InputRgbGc() )

        {

        DrawHighlightBackground( *iAnimation->InputRgbGc() );

        }

    iAnimation->EndConfigInputLayersL();

    }

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

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

// Constructor

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

//

CAknStylusPopUpMenuContent::CAknStylusPopUpMenuContent( CAknStylusPopUpMenu& aPopUpMenu ) : 

    iItems( KItemArrayGranularity ), 

    iCurrentItem( KNoItemSelected ),

    iFirstItem ( 0 ),

    iPopUpMenu( aPopUpMenu ),

    iPhysicsHandler( 0 )

    {

    }

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

// CAknStylusPopUpMenuContent::ConstructL

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

//

void CAknStylusPopUpMenuContent::ConstructL()

    {

    if ( !iExtension )

        {

        iExtension = new (ELeave) CAknStylusPopUpMenuExtension;

        iExtension->ConstructL( this );

        }

   if ( !iPhysicsHandler )

        {

        iPhysicsHandler = CAknStylusPopUpMenuPhysicsHandler::NewL( this );

        }     

    ControlEnv()->AddForegroundObserverL( *this );

    MakeVisible( EFalse );

    }

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

// CAknStylusPopUpMenuContent::NewL

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

//

CAknStylusPopUpMenuContent* CAknStylusPopUpMenuContent::NewL( CAknStylusPopUpMenu& aPopUpMenu )

    {

    CAknStylusPopUpMenuContent* self = CAknStylusPopUpMenuContent::NewLC( aPopUpMenu );

    CleanupStack::Pop( self );

    return self;

    }

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

// CAknStylusPopUpMenuContent::NewLC

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

//

CAknStylusPopUpMenuContent* CAknStylusPopUpMenuContent::NewLC( CAknStylusPopUpMenu& aPopUpMenu )

    {

    CAknStylusPopUpMenuContent* self = new ( ELeave ) CAknStylusPopUpMenuContent( aPopUpMenu );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CAknStylusPopUpMenuContent::~CAknStylusPopUpMenuContent()

    {

    delete iPhysicsHandler;

    iItems.ResetAndDestroy();

    CCoeEnv::Static()->RemoveForegroundObserver( *this );

    delete iExtension; 

    if ( iSBFrame )

        {