/*

* Copyright (c) 2006 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:  Button class.

*

*/

// INCLUDE FILES

#include    <aknappui.h>

#include    <AknIconArray.h>

#include    <aknsoundsystem.h>  // CAknKeySoundSystem

#include    <AknsConstants.h>

#include    <aknconsts.h>

#include    <AknsUtils.h>

#include    <barsread.h>

#include    <gulicon.h>

#include    <coedef.h>

#include    <eiksvdef.h>

#include    <AknsDrawUtils.h>

#include    "mpxbutton.h"

#include    "mpxplaybackviewlayoutinterface.h"

#include    "mpxcommonplaybackview.hrh"

#include    "mpxlog.h"

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

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

// CMPXButton::CMPXButton

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

//

CMPXButton::CMPXButton(

    TMPXPbvButton aButtonId,

    MMPXButtonCmdObserver* aObserver,

    MMPXPlaybackViewLayout* aLayout )

    : iButtonId( aButtonId ),

      iCurrentStateIndex( KErrNotFound ),

      iObserver( aObserver ), 

      iVisible( ETrue ),

      iLayout( aLayout )

    {

    MPX_FUNC("CMPXButton::CMPXButton()");

    }

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

// CMPXButton::NewLC

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

//

CMPXButton* CMPXButton::NewLC(

    TMPXPbvButton aButtonId,

    MMPXButtonCmdObserver* aObserver,

    MMPXPlaybackViewLayout* aLayout )

    {

    MPX_FUNC("CMPXButton::NewLC()");

    CMPXButton* self = new (ELeave) CMPXButton(

        aButtonId,

        aObserver,

        aLayout );

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CMPXButton::NewL

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

//

CMPXButton* CMPXButton::NewL(

    TMPXPbvButton aButtonId,

    MMPXButtonCmdObserver* aObserver,

    MMPXPlaybackViewLayout* aLayout )

    {

    MPX_FUNC("CMPXButton::NewL()");

    CMPXButton* self = CMPXButton::NewLC(

        aButtonId,

        aObserver,

        aLayout );

    CleanupStack::Pop(self);

    return self;

    }

// Destructor

CMPXButton::~CMPXButton()

    {

    MPX_FUNC("CMPXButton::~CMPXButton()");

    FreeIcons();

    iButtonArray.ResetAndDestroy();

    if (iTimer)

        {

        iTimer->Cancel();

        delete iTimer;

        }

    }

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

// CMPXButton::ConstructL

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

//

void CMPXButton::ConstructL()

    {

    MPX_FUNC("CMPXButton::ConstructL()");

    iKeySoundSystem = static_cast<CAknAppUi*>(

        CEikonEnv::Static()->AppUi())->KeySounds();

    iTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    }

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

// CMPXButton::AddStateL

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

//

void CMPXButton::AddStateL(

    TInt aState,

    TInt aEnterCommand,

    TInt aExitCommand,

    TInt aLongEnterCommand,

    TInt aLongExitCommand )

    {

    MPX_DEBUG1("CMPXButton::AddStateL() entering");

    TMPXButtonInfo* info = new (ELeave) TMPXButtonInfo;

    CleanupStack::PushL( info );

    info->iState = aState;

    info->iEnterCommand = aEnterCommand;

    info->iExitCommand = aExitCommand;

    info->iLongEnterCommand = aLongEnterCommand;

    info->iLongExitCommand = aLongExitCommand;

    info->iBitmap = LoadIconL( aState );

    iButtonArray.AppendL(info);

    CleanupStack::Pop( info );

    MPX_DEBUG1("CMPXButton::AddStateL() exiting");

    }

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

// CMPXButton::Id

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

//

TMPXPbvButton CMPXButton::Id() const

    {

    return iButtonId;

    }

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

// CMPXButton::MakeVisible

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

//

void CMPXButton::MakeVisible(

    TBool aVisible )

    {

    iVisible = aVisible;

    }

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

// CMPXButton::IsVisible

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

//

TBool CMPXButton::IsVisible() const

    {

    return iVisible;

    }

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

// CMPXButton::SetButtonState

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

//

void CMPXButton::SetButtonState(

    TInt aState,

    TBool aNotifyExit /*=EFalse=*/,

    TBool aNotifyEnter /*=EFalse*/ )

    {

    MPX_DEBUG4("CMPXButton::SetButtonState(%d, %d, %d): entering", aState, aNotifyExit, aNotifyEnter);

    TInt index( KErrNotFound );

    TMPXButtonInfo* info( NULL );

    // Find the new state

    for (TInt i = 0; i < iButtonArray.Count(); i++)

        {

        info = iButtonArray[i];

        if ( info->iState == aState )

            {

            index = i;

            }

        }

    if ( KErrNotFound != index &&

         iCurrentStateIndex != index )

        {

        if ( aNotifyExit || aNotifyEnter )

            {

            if ( aNotifyExit )

                {

                // Execute the previous state's exit command

                info = iButtonArray[iCurrentStateIndex];

                if ( iIsLongPress )

                    {

                    if ( info->iLongExitCommand != KErrNone )

                        {

                        TRAP_IGNORE(

                            iObserver->HandleButtonCommandL( info->iLongExitCommand ));

                        }

                    }

                else if ( info->iExitCommand != KErrNone )

                    {

                    TRAP_IGNORE(

                        iObserver->HandleButtonCommandL( info->iExitCommand ));

                    }

                // Reset long press flag

                iIsLongPress = EFalse;

                }

            info = iButtonArray[index];

            if ( aNotifyEnter )

                {

                // Now execute the new state's enter command

                if ( info->iEnterCommand != KErrNone )

                    {

                    TRAP_IGNORE( 

                        iObserver->HandleButtonCommandL( info->iEnterCommand ));

                    }

                }

            // start the timer

            iTimer->Cancel();

            if ( info->iLongEnterCommand != KErrNone )

                {

                iTimer->Start( KAknKeyboardRepeatInitialDelay,

                               KAknKeyboardRepeatInitialDelay,

                               TCallBack(TimerCallback, this ));

                }

            }

        iCurrentStateIndex = index;

        iNeedRedraw = ETrue;

        }

    MPX_DEBUG1("CMPXButton::SetButtonState(): exiting");

    }

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

// CMPXButton::CurrentState

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

//

TInt CMPXButton::CurrentState() const

    {

    MPX_DEBUG1("CMPXButton::CurrentState() entering");

    ASSERT( iCurrentStateIndex < iButtonArray.Count() );

    TInt state( iButtonArray[iCurrentStateIndex]->iState );

    MPX_DEBUG2("CMPXButton::CurrentState() exiting: %d", state);

    return state;

    }

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

// CMPXButton::RedrawRect

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

//

void CMPXButton::RedrawRect(

    CBitmapContext& aGc, 

    const TRect& aRect ) const

    {

    MPX_DEBUG1("CMPXButton::RedrawRect() entering");

    if (iVisible && aRect.Intersects(iRect))

        {

        if (iBackground)

            {

            MPX_DEBUG1("CMPXButton::RedrawRect() redrawing background");

            MAknsSkinInstance* skin = AknsUtils::SkinInstance();

            AknsDrawUtils::DrawBackground(

                skin, 

                iBackground, 

                NULL, 

                aGc, 

                iRect.iTl, 

                iRect, 

                KAknsDrawParamDefault );

            }

        MPX_DEBUG2("CMPXButton::RedrawRect(): iCurrentStateIndex = %d", iCurrentStateIndex);

        ASSERT( iCurrentStateIndex < iButtonArray.Count() );

        TMPXButtonInfo* info( iButtonArray[iCurrentStateIndex] );

        CGulIcon* icon( info->iBitmap );

        if ( icon )

            {

            ASSERT( icon->Bitmap() && icon->Mask() );

            MPX_DEBUG1("CMPXButton::RedrawRect() redrawing icon");

            aGc.BitBltMasked(

                iRect.iTl, // aPoint

                icon->Bitmap(), // aBitmap

                TRect(TPoint(), iRect.Size()), // aSourceRect

                icon->Mask(),

                EFalse); // aInvertMask

            }

        }

    MPX_DEBUG1("CMPXButton::RedrawRect() exiting");

    }

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

// CMPXButton::ReloadIconsL

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

//

void CMPXButton::ReloadIconsL(

    const TRect& aParentRect )

    {

    MPX_DEBUG1("CMPXButton::ReloadIconsL() entering");

    iParentRect = aParentRect;

    FreeIcons();

    iRect = iLayout->ButtonLayout( aParentRect );

    for (TInt i = 0; i < iButtonArray.Count(); i++)

        {

        TMPXButtonInfo* info( iButtonArray[i] );

        info->iBitmap = LoadIconL( info->iState );

        AknIconUtils::SetSize(

            info->iBitmap->Bitmap(),

            iRect.Size() );

        }    

    MPX_DEBUG1("CMPXButton::ReloadIconsL() exiting");

    }

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

// CMPXButton::SetBackground

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

//

void CMPXButton::SetBackground(

    MAknsControlContext* aBackground)

    {

    ASSERT( aBackground );

    iBackground = aBackground;

    }

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

// CMPXButton::NeedRedraw

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

//

TBool CMPXButton::NeedRedraw() const

    {

    return iNeedRedraw;

    }

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

// CMPXButton::ClearRedrawFlag

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

//

void CMPXButton::ClearRedrawFlag()

    {

    iNeedRedraw = EFalse;

    }

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

// CMPXButton::LoadIconL

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

//

CGulIcon* CMPXButton::LoadIconL(

    TInt aState )

    {

    MPX_DEBUG1("CMPXButton::LoadIconL() entering");

    CFbsBitmap* bitmap = NULL;

    CFbsBitmap* mask = NULL;

    iLayout->GetButtonBitmapsL(

        iButtonId, 

        aState, 

        bitmap, 

        mask);

    CleanupStack::PushL(bitmap);

    CleanupStack::PushL(mask);

    CGulIcon* res = CGulIcon::NewL(bitmap, mask);

    CleanupStack::Pop(2); // bitmap, mask

    MPX_DEBUG1("CMPXButton::LoadIconL() exiting");

    return res;

    }

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

// CMPXButton::FreeIcons

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

//

void CMPXButton::FreeIcons()

    {

    MPX_DEBUG1("CMPXButton::FreeIcons() entering");

    for ( TInt i = 0; i < iButtonArray.Count(); i++ )

        {

        TMPXButtonInfo* info( iButtonArray[i] );

        delete info->iBitmap;

        info->iBitmap = NULL;

        }

    MPX_DEBUG1("CMPXButton::FreeIcons() exiting");

    }

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

// CMPXButton::HandleKeyRepeat

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

//

void CMPXButton::HandleLongPress()

    {

    MPX_DEBUG1("CMPXButton::HandleLongPress() entering");

    iIsLongPress = ETrue;

    TMPXButtonInfo* info( iButtonArray[iCurrentStateIndex] );

    if ( info->iLongEnterCommand != KErrNone )

        {

        if( !(info->iLongEnterCommand == EMPXPbvCmdIncreaseVolume || 

              info->iLongEnterCommand == EMPXPbvCmdDecreaseVolume ))

            {

            iTimer->Cancel();    

            }

        TRAP_IGNORE(iObserver->HandleButtonCommandL( info->iLongEnterCommand ));

        }

    MPX_DEBUG1("CMPXButton::HandleLongPress() exiting");

    }

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

// CMPXButton::TimerCallback

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

//

TInt CMPXButton::TimerCallback(

    TAny* aPtr )

    {

    MPX_DEBUG1("CMPXButton::TimerCallback() entering");

    static_cast<CMPXButton*>(aPtr)->HandleLongPress();

    MPX_DEBUG1("CMPXButton::TimerCallback() exiting");

    return KErrNone;

    }

//  End of File