/*
* 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:  Implementation of Common Playback view's container.
*
*/



// INCLUDE FILES
#include <eiklabel.h>
#include <eikimage.h>
#include <eikprogi.h>
#include <eikmenub.h>
#include <eikappui.h>
#include <eikenv.h>
#include <aknview.h>
#include <AknsUtils.h>
#include <AknDef.h>
#include <AknsConstants.h>
#include <AknsSkinInstance.h>
#include <AknsControlContext.h>
#include <AknsDrawUtils.h>
#include <AknsBasicBackgroundControlContext.h>
#include <barsread.h>
#include <centralrepository.h>
#include <StringLoader.h>
#include <fontids.hrh>
#include <gulfont.h>
#include <applayout.cdl.h>
#include <AknIconArray.h>
#include <AknIconUtils.h>
#include <gulicon.h>
#include <featmgr.h>
#include <aknnotewrappers.h>

#include <data_caging_path_literals.hrh>
#include <aknlayoutscalable_apps.cdl.h>
#include <layoutmetadata.cdl.h>
#include <avkon.mbg>
#include <mpxcommonplaybackview.rsg>
#include <mpxcommonplaybackview.mbg>
#include <mpxconstants.h>
#include <mpxfmtx.rsg> // For FF_FMTX
#include <mpxappui.hrh>
#include <mpxinternalcrkeys.h>
#include <touchfeedback.h>
#include <akntranseffect.h>                 // For transition effects
#include <gfxtranseffect/gfxtranseffect.h>  // For transition effects

#include "mpxcommonplaybackviewcontainer.h"
#include "mpxcommonplaybackviewlayout.h"
#include "mpxcommonplaybackview.hrh"
#include "mpxplaybackview.hlp.hrh"
#include "mpxplaybackviewinfolabel.h"
#include "mpxplaybackviewlayoutinterface.h"
#include "mpxlayoutswitchobserver.h"
#include "mpxcommonuihelper.h"
#include "mpxbuttonmanager.h"
#include "mpxlog.h"

// CONSTANTS
const TInt KLabelCount = ETextCount;
const TInt KMPXMinSecSeparatorIndex = 2;

_LIT(KMPXZeroDurationMark, "--");

const TInt KOneHourInSeconds = 3600;
const TInt KMPXTimeIndicatorLength = 16;

// S60 softkey positions in CBA
const TInt KMPXCbaLeftSoftkeyPos = 0;
const TInt KMPXCbaRightSoftkeyPos = 2;

// delay for actual seek operation
const TInt KSeekDelay = 100000; // 0.1s

const TInt KOneSecondInOneMilliSecond = 1000;
// ======== MEMBER FUNCTIONS ========


// ---------------------------------------------------------------------------
// Symbian 2nd phase constructor can leave.
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::ConstructL( const TRect& /*aRect*/ )
    {
    MPX_DEBUG1( "CMPXCommonPlaybackViewContainer::ConstructL() entering" );

    CreateWindowL();

    TAknWindowLineLayout screenLayout =
        AknLayout::screen();
    TRect screenRect = screenLayout.Rect();
	iBackground = CAknsBasicBackgroundControlContext::NewL(
			KAknsIIDQsnBgAreaMain, screenRect, EFalse );

	iSeekTimer = CPeriodic::NewL( EPriorityLow );

    TInt flags( 0 );
    CRepository* repository = CRepository::NewL( KCRUidMPXMPFeatures );
    User::LeaveIfError( repository->Get( KMPXMPLocalVariation, flags ));
    delete repository;
    repository = NULL;

    iEnableMarquee = static_cast<TBool>( flags & KMPXMarqueeArtistName );

    iEnableButtons = static_cast<TBool>( flags & KMPXRockerMappingSupport );


    // Create labels
    CreateLabelsL();
    iLabels[ETextPlaylistCount]->MakeVisible( ETrue );

	if ( FeatureManager::FeatureSupported( KFeatureIdFmtx ) )
		{
    	// By default, FMTX label is displayed
    	iLabels[ETextFMFrequency]->MakeVisible( ETrue );
    	SetFMTXMode(ETrue);
		}

    // Create icons
    CreateIconsL();

    // Create buttons if enabled
    if ( iEnableButtons )
        {
        TRect rockerParentRect;
        if ( iCurrentLayout.Width())
        {
            rockerParentRect = iCurrentLayout;
        }
        else
        {
            rockerParentRect = iCurrentLayout;
        }

        iButtonManager = CMPXButtonManager::NewL(
            this,
            iLayout,
            *this);

        iButtonManager->SetContainerWindowL( *this );
        iButtonManager->SetMopParent( this );
        iButtonManager->SetRect(rockerParentRect);
        }

     // Read time format strings from AVKON resource
    iMinSecFormatString = StringLoader::LoadL(
        R_QTN_TIME_DURAT_MIN_SEC_WITH_ZERO );

    iShortFormatString =
        StringLoader::LoadL( R_QTN_TIME_DURAT_SHORT_WITH_ZERO );

    iCommonUiHelper = CMPXCommonUiHelper::NewL();

    // Refresh the progress bar
    UpdateProgressBarGraphics();

    iMode = EUninitialized;
    // suppress download text per UI spec
    iLabels[ETextDownloadState]->MakeVisible( EFalse );
    iLabels[ETextArtist]->MakeVisible( EFalse );
    iLabels[ETextTrack]->MakeVisible( EFalse );
    iLabels[ETextElapsedTime]->MakeVisible( EFalse );
    iLabels[ETextRemainingTime]->MakeVisible( EFalse );
    iDisplayAlbumArt = EFalse;
    ActivateL();

    iTouchDown = EFalse;
    iActiveView = ETrue;
    iPrerollCompleted = EFalse;

    iLightStatus = CHWRMLight::ELightStatusUnknown;
    iIsForeground = EFalse ;
    iLight = CHWRMLight::NewL(this);

	DrawableWindow()->SetPointerGrab( ETrue );
    EnableDragEvents();

    MPX_DEBUG1( "CMPXCommonPlaybackViewContainer::ConstructL() exiting" );
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
EXPORT_C CMPXCommonPlaybackViewContainer::~CMPXCommonPlaybackViewContainer()
    {
    // Pointer events
    SetGloballyCapturing( EFalse );
    SetPointerCapture( EFalse );

    FreeIcons();
    delete iTrackAlbumArt;

    delete iBackground;
    iLabels.ResetAndDestroy();
    delete iMinSecFormatString;
    delete iShortFormatString;
    delete iCommonUiHelper;

    if ( iLight )
        {
        delete iLight;
        iLight = NULL;
        }

    delete iButtonManager;

   MTouchFeedback* feedback = MTouchFeedback::Instance();
   if (feedback)
       {
       feedback->RemoveFeedbackForControl(this);
       }

    if ( iIdle )
        {
        iIdle->Cancel();
        delete iIdle;
        }

	if ( iSeekTimer )
		{
		iSeekTimer->Cancel();
		delete iSeekTimer;
		}
    }

// ---------------------------------------------------------------------------
// Updates time indicators.
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::UpdateTimeIndicatorsL(
    TInt aPlaybackPosInSeconds,
    TInt aTotalLengthInSeconds )
    {
    iTrackTotalLengthInSeconds = aTotalLengthInSeconds;
    if (!iTouchDown)
        {
        if( iDragProgressBar )
          {
          TInt expectPlaybackPos = iNewSongPosition / KOneSecondInOneMilliSecond;
          if( expectPlaybackPos == aPlaybackPosInSeconds )
              {
              iDragProgressBar = EFalse;
              }
          else
              {
              return;
              }
          }
    if ( aTotalLengthInSeconds == 0 )
        {
        TLocale locale;
        TBuf<KMPXTimeIndicatorLength> pos;
        TChar separator = locale.TimeSeparator( KMPXMinSecSeparatorIndex );
        pos = KMPXZeroDurationMark;
        pos.Append( separator );
        pos += KMPXZeroDurationMark;

        UpdateLabelL( ETextElapsedTime, pos );
        UpdateLabelL( ETextRemainingTime, pos );
        }
    else
        {
        CMPXCommonUiHelper::TMPXDuratDisplayMode durationMode =
            CMPXCommonUiHelper::EMPXDuratAuto;
        if ( aTotalLengthInSeconds > KOneHourInSeconds )
            {
            durationMode = CMPXCommonUiHelper::EMPXDuratHMS;
            }

        // Convert ellapsed time to texts
        HBufC* position = iCommonUiHelper->DisplayableDurationL(
            aPlaybackPosInSeconds,
            durationMode );
        CleanupStack::PushL( position );

        TInt remainingTime = aTotalLengthInSeconds - aPlaybackPosInSeconds;
        if ( remainingTime < 0 )
            {
            // Convert all negative value to zero
            remainingTime = 0;
            }

        // Convert remaining time to texts
        HBufC* remaining = iCommonUiHelper->DisplayableDurationL(
            remainingTime,
            durationMode );
        CleanupStack::PushL( remaining );

        UpdateLabelL( ETextElapsedTime, *position );
        UpdateLabelL( ETextRemainingTime, *remaining );

        CleanupStack::PopAndDestroy( remaining );
        CleanupStack::PopAndDestroy( position );
        }

    if ( ( iMode != EUninitialized )
         || ( iMode == EPlayMode || iMode == EPauseMode ) )
        {
        if ( aTotalLengthInSeconds )
            {
            TReal t = aTotalLengthInSeconds;
            iPlaybackRatio = aPlaybackPosInSeconds / t;
            }
        RefreshProgressBar();
        }
        }
    }

// ---------------------------------------------------------------------------
// Updates label
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::UpdateLabelL(
    TMPXPbvTextIndicator aLabel,
    const TDesC& aText )
    {
    ASSERT( aLabel >= 0 && aLabel < iLabels.Count() );
    CMPXPlaybackViewInfoLabel* label = iLabels[aLabel];
    if(aLabel == ETextDownloadState)
        {
		/*
        iSliderPaneRect = iLayout->IndicatorLayout( Rect(), ESliderPane );
        iLayout->LayoutLabel(
        iLabels[ETextDownloadState], iSliderPaneRect, ETextDownloadState );

        MAknsSkinInstance* skin = AknsUtils::SkinInstance();
        TRgb color = KRgbBlack;

        AknsUtils::GetCachedColor(
            skin,
            color,
            KAknsIIDQsnTextColors,
            EAknsCIQsnTextColorsCG50 );

        AknLayoutUtils::OverrideControlColorL(
            *iLabels[ETextDownloadState],
            EColorLabelText,
            color );
        */
        // suppress download text per UI spec.
        return;
        }
    if ( label )
        {
        TBool needRedraw = EFalse;

        if ( label->FullText() != aText )
            {
            needRedraw = ETrue;
            label->SetLabelTextL( aText);
            }

        if ( needRedraw && label->IsVisible() )
            {
            label->StartMarquee();
            label->DrawDeferred();
            }
        }
    }

// ---------------------------------------------------------------------------
// Sets main pane mode.
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::SetMode( TMPXPbvPlaybackMode aMode )
    {
    iMode = aMode;
    iDisplayAlbumArt = ETrue;

    switch ( iMode )
        {
	    case EUninitialized:
	    	{
	    	// Set label visibility
	        //iLabels[ETextDownloadState]->MakeVisible( EFalse );
	        iLabels[ETextArtist]->MakeVisible( ETrue );
	        iLabels[ETextTrack]->MakeVisible( ETrue );
	        //iLabels[ETextEmpty]->MakeVisible( EFalse );
	        iLabels[ETextElapsedTime]->MakeVisible( ETrue && iPrerollCompleted);
	        iLabels[ETextRemainingTime]->MakeVisible( ETrue && iPrerollCompleted);
        	break;
        	}
        case ENoTracksMode:
            {
            // Set label visibility
            //iLabels[ETextDownloadState]->MakeVisible( ETrue );
            iLabels[ETextArtist]->MakeVisible( EFalse );
            iLabels[ETextTrack]->MakeVisible( EFalse );
            //iLabels[ETextEmpty]->MakeVisible( ETrue );
            iLabels[ETextElapsedTime]->MakeVisible( ETrue && iPrerollCompleted);
            iLabels[ETextRemainingTime]->MakeVisible( ETrue && iPrerollCompleted);
            iDisplayAlbumArt = EFalse;
            break;
            }
        case EStopMode:
            {
            // Fixed the layout for Download label and time label are overlaped in position
            //iLabels[ETextDownloadState]->MakeVisible( EFalse );
            iLabels[ETextTrack]->MakeVisible( ETrue );
            iLabels[ETextArtist]->MakeVisible( ETrue );
            //iLabels[ETextEmpty]->MakeVisible( EFalse );
            iLabels[ETextElapsedTime]->MakeVisible( ETrue && iPrerollCompleted);
            iLabels[ETextRemainingTime]->MakeVisible( ETrue && iPrerollCompleted);
            break;
            }
        case EInitialising:
            {
            //iLabels[ETextDownloadState]->MakeVisible( ETrue );
            iLabels[ETextTrack]->MakeVisible( ETrue );
            iLabels[ETextArtist]->MakeVisible( ETrue );
            //iLabels[ETextEmpty]->MakeVisible( EFalse );
            iLabels[ETextElapsedTime]->MakeVisible( ETrue && iPrerollCompleted);
            iLabels[ETextRemainingTime]->MakeVisible( ETrue && iPrerollCompleted);
            break;
            }
        case EMediaKeySkipping:
            {
            //iLabels[ETextDownloadState]->MakeVisible( ETrue );
            iLabels[ETextTrack]->MakeVisible( ETrue );
            iLabels[ETextArtist]->MakeVisible( ETrue );
            //iLabels[ETextEmpty]->MakeVisible( EFalse );
            iLabels[ETextElapsedTime]->MakeVisible( ETrue && iPrerollCompleted);
            iLabels[ETextRemainingTime]->MakeVisible( ETrue && iPrerollCompleted);
            break;
            }
        case EInvalidMode:
            {
            //iLabels[ETextDownloadState]->MakeVisible( EFalse );
            iLabels[ETextTrack]->MakeVisible( EFalse );
            iLabels[ETextArtist]->MakeVisible( EFalse );
            //iLabels[ETextEmpty]->MakeVisible( EFalse );
            iLabels[ETextElapsedTime]->MakeVisible( ETrue && iPrerollCompleted);
            iLabels[ETextRemainingTime]->MakeVisible( ETrue && iPrerollCompleted);

            break;
            }
        case EBufferingMode:
            {
            // Set label visibility
            //iLabels[ETextDownloadState]->MakeVisible( EFalse );
            iLabels[ETextArtist]->MakeVisible( ETrue );
            iLabels[ETextTrack]->MakeVisible( ETrue );
            //iLabels[ETextEmpty]->MakeVisible( EFalse );
            iLabels[ETextElapsedTime]->MakeVisible( ETrue && iPrerollCompleted);
            iLabels[ETextRemainingTime]->MakeVisible( ETrue && iPrerollCompleted);
            break;
            }
        default:
            {
            // Set label visibility
            //iLabels[ETextDownloadState]->MakeVisible( EFalse );
            iLabels[ETextArtist]->MakeVisible( ETrue );
            iLabels[ETextTrack]->MakeVisible( ETrue );
            //iLabels[ETextEmpty]->MakeVisible( EFalse );
            iLabels[ETextElapsedTime]->MakeVisible( ETrue && iPrerollCompleted);
            iLabels[ETextRemainingTime]->MakeVisible( ETrue && iPrerollCompleted);
            break;
            }
        }

    if ( iMode == EPlayMode )
        {
        iLabels[ETextArtist]->StartMarquee();
        iLabels[ETextTrack]->StartMarquee();
        }
    else
        {
        iLabels[ETextArtist]->StopMarquee();
        iLabels[ETextTrack]->StopMarquee();
        }
    DrawDeferred();
    }

// ---------------------------------------------------------------------------
// Set random mode.
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::SetRandomMode( TBool aRandomMode )
    {
    iRandomMode = aRandomMode;
    Window().Invalidate( iRandomIconRect );
    }

// ---------------------------------------------------------------------------
// Set repeat mode.
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::SetRepeatMode(
    TBool aRepeatAll,
    TBool aRepeatOne )
    {
    iRepeatAllMode = aRepeatAll;
    iRepeatOneMode = aRepeatOne;
    Window().Invalidate( iRepeatIconRect );
    }

// ---------------------------------------------------------------------------
// Set RealPlayer mode.
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::SetRealAudioMode(
    TBool aRealAudioMode )
    {
#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER
    iRealAudioMode = aRealAudioMode;
    Window().Invalidate( iRealIconRect );
#else
    (void) aRealAudioMode;
    ASSERT( 0 );
#endif
    }

// -----------------------------------------------------------------------------
// CMPXCommonPlaybackViewContainer::UpdateButtons
// -----------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::UpdateButtons(
    TMPXPlaybackState aState )
    {
    if ( iEnableButtons )
        {
        iButtonManager->UpdateButtonStates( aState );
        DrawDeferred();
        }
    }

// ---------------------------------------------------------------------------
// Set layout for all elements and set sizes for icons.
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::UpdateLayout()
    {
    MPX_FUNC( "CMPXCommonPlaybackViewContainer::UpdateLayout" );
    TRAP_IGNORE( DoUpdateLayoutL() );
    }

// ---------------------------------------------------------------------------
// Updates duration label.
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::UpdateDurationLabelL(
    TInt aTotalLengthInSeconds )
    {
    HBufC* labelText( NULL );
    HBufC* duration( NULL );

    if ( aTotalLengthInSeconds == 0 )
        {
        TLocale locale;
        TChar separator = locale.TimeSeparator( KMPXMinSecSeparatorIndex );

        duration = HBufC::NewLC( KMPXTimeIndicatorLength );
        TPtr durationTPtr( duration->Des() );

        durationTPtr = KMPXZeroDurationMark;
        durationTPtr.Append( separator );
        durationTPtr += KMPXZeroDurationMark;
        }
    else
        {
        // Convert track duration to text
        duration = iCommonUiHelper->DisplayableDurationL(
            aTotalLengthInSeconds );
        CleanupStack::PushL( duration );
        }

    labelText = StringLoader::LoadLC(
        R_MPX_PBV_TRACK_DURATION_FORMAT,
        *duration );

    CleanupStack::PopAndDestroy( labelText );
    CleanupStack::PopAndDestroy( duration );
    }

// ---------------------------------------------------------------------------
// Force softkey label colors to what is specified in skin
// for Music Player soft keys.
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::UpdateSoftkeyColors()
    {
    CEikButtonGroupContainer* cbgc = CEikButtonGroupContainer::Current();
    MEikButtonGroup* bg = NULL;
    if ( cbgc )
        {
        bg = cbgc->ButtonGroup();
        }

    if ( bg )
        {
        MAknsSkinInstance* skin = AknsUtils::SkinInstance();

        TRgb color = KRgbBlack;
        CCoeControl* lsk = cbgc->ControlOrNull(
            bg->CommandId( KMPXCbaLeftSoftkeyPos ) );
        if ( lsk )
            {
            // Color is not updated if it not found from the skin
            if (!AknsUtils::GetCachedColor(
                skin, color, KAknsIIDQsnTextColors,
                EAknsCIQsnTextColorsCG47 ) )
                {
                TRAP_IGNORE(
                    AknLayoutUtils::OverrideControlColorL( *lsk,
                    EColorLabelText,
                    color ) );
                }
            }

        CCoeControl* rsk = cbgc->ControlOrNull(
            bg->CommandId( KMPXCbaRightSoftkeyPos ) );
        if ( rsk )
            {
            // Color is not updated if it not found from the skin
            if ( !AknsUtils::GetCachedColor(
                skin, color, KAknsIIDQsnTextColors,
                EAknsCIQsnTextColorsCG46 ) )
                {
                TRAP_IGNORE(
                    AknLayoutUtils::OverrideControlColorL( *rsk,
                    EColorLabelText,
                    color ) );
                }
            }
        cbgc->DrawDeferred();
        }
    }

// ---------------------------------------------------------------------------
// Handles foreground events
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::HandleForegroundEventL(
    TBool aForeground )
    {
    MPX_FUNC( "CMPXCommonPlaybackViewContainer::HandleForegroundEventL" );

    iIsForeground = aForeground;

    if ( !aForeground && iEnableButtons )
        {
        // if losing foreground and buttons are enabled
        iButtonManager->HandleForegroundLostL();
        }

    if ( !aForeground && iTouchDown )
        {
        // Pointer events
        SetGloballyCapturing( EFalse );
        SetPointerCapture( EFalse );

        iTouchDown = EFalse;
        }

	// Special case: if going to background but still partially visible
	if( iActiveView && !aForeground )
		{
		CAknAppUi* appUi = (CAknAppUi*)CEikonEnv::Static()->AppUi();
		if( !appUi->IsFaded() )
		    {
		    iActiveView = EFalse;
		    }
		}
	else
		{
		iActiveView = aForeground;
		}

    RefreshProgressBar();
    }

// ---------------------------------------------------------------------------
// From MMPXAlbumArtUtilObserver
// Notify that extraction of album art started.
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::ExtractAlbumArtStarted()
    {
    MPX_DEBUG1("CMPXCommonPlaybackViewContainer::ExtractAlbumArtStarted(): Entering");

    MPX_DEBUG1("CMPXCommonPlaybackViewContainer::ExtractAlbumArtStarted(): Exiting");
    }


// ---------------------------------------------------------------------------
// From MMPXAlbumArtUtilObserver
// Album art is extracted from file and ready to use.
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::ExtractAlbumArtCompleted(
    CFbsBitmap* aBitmap,
    TInt aErr )
    {
    // Here we are making the assumption that if we get an update on album
    // art, it is Ok to Start displaying the items.
    iLabels[ETextTrack]->MakeVisible( ETrue );
    iLabels[ETextArtist]->MakeVisible( ETrue );
    iLabels[ETextElapsedTime]->MakeVisible( ETrue);
    iLabels[ETextRemainingTime]->MakeVisible( ETrue);
    iPrerollCompleted = ETrue;

    MPX_DEBUG3( "CMPXCommonPlaybackViewContainer::ExtractAlbumArtCompleted(bitmap:0x%x, err:%d)",
        aBitmap, aErr );

    delete iTrackAlbumArt;
    iTrackAlbumArt = NULL;

    if ( aBitmap && KErrNone == aErr )
        {
        iTrackAlbumArt = aBitmap;
        }

    DrawDeferred();
    }

// ---------------------------------------------------------------------------
// From CCoeControl
// Handles key events.
// ---------------------------------------------------------------------------
//
EXPORT_C TKeyResponse CMPXCommonPlaybackViewContainer::OfferKeyEventL(
    const TKeyEvent& aKeyEvent,
    TEventCode aType )
    {
    MPX_DEBUG4( "CMPXCommonPlaybackViewContainer::OfferKeyEventL(iCode=%d, iScanCode=%d, aType=%d)",
        aKeyEvent.iCode, aKeyEvent.iScanCode, aType );

    TKeyResponse response = EKeyWasNotConsumed;

    if ( iEnableButtons )
        {
        response = iButtonManager->OfferKeyEventL( aKeyEvent, aType );
        if ( response == EKeyWasConsumed )
            {
            CWindowGc& gc = SystemGc();
            gc.Activate( *DrawableWindow() );
//            iButtonManager->RedrawIfNeeded(gc);
            gc.Deactivate();
            }
        }

    if ( response == EKeyWasNotConsumed )
        {
// TODO
/*
        if ( aKeyEvent.iCode == EKeyLeftArrow && !FeatureManager::FeatureSupported(
                    KFeatureIdSideVolumeKeys ))
            {
            iCommandObserver->ProcessCommandL( EMPlayerCmdDecreaseVolume) ;
            response = EKeyWasConsumed;
            }
        else if ( aKeyEvent.iCode == EKeyRightArrow && !FeatureManager::FeatureSupported(
                    KFeatureIdSideVolumeKeys ))
            {
            iCommandObserver->ProcessCommandL( EMPlayerCmdIncreaseVolume );
            response = EKeyWasConsumed;
            }
        else
            {
            // Do nothing
            }
*/
        }

    return response;
    }

// ---------------------------------------------------------------------------
// From CCoeControl
// Handles a change to the control's resources.
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::HandleResourceChange( TInt aType )
    {
    CCoeControl::HandleResourceChange( aType );

    if ( aType == KAknsMessageSkinChange )
        {
        // Reload icons
        TRAP_IGNORE(
            {
            CreateIconsL();
            } );

        // Make sure execute layout again
        iCurrentLayout = TRect();
        UpdateLayout(); // To make sure AknIconUtils::SetSize() gets called
        }
    else if ( aType == KEikDynamicLayoutVariantSwitch )
        {
        iLayoutObserver->HandleLayoutChange();
        }
    else
        {
        // pass
        }
    }

// ---------------------------------------------------------------------------
// From CCoeControl
// Gets the control's help context.
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::GetHelpContext(
    TCoeHelpContext& aContext ) const
    {
    aContext.iMajor = KAppUidMusicPlayerX;
/*
    if ( iIsEmbedded )
        {
        // TODO: Handle for embedded mode
        aContext.iContext = KMUS_HLP_PLAYBACK_VIEW;
        }
    else
        {
        aContext.iContext = KMUS_HLP_PLAYBACK_VIEW;
        }
*/
    }

// ---------------------------------------------------------------------------
// Starts marquee for a playback label
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::StartMarquee(
    TMPXPbvTextIndicator aLabel )
    {
    MPX_FUNC( "CMPXCommonPlaybackViewContainer::StartMarquee" );
    ASSERT( aLabel >= 0 && aLabel < iLabels.Count() );
    CMPXPlaybackViewInfoLabel* label = iLabels[aLabel];
    if ( label )
        {
        if ( label->IsVisible() )
            {
            label->StartMarquee();
            label->DrawDeferred();
            }
        }
    }

// ---------------------------------------------------------------------------
// Creates labels.
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::CreateLabelsL()
    {
    CMPXPlaybackViewInfoLabel* label = NULL;

    for ( TInt index = 0; index < KLabelCount; ++index )
        {
        label = new ( ELeave ) CMPXPlaybackViewInfoLabel();
        CleanupStack::PushL( label );
        label->SetContainerWindowL( *this );
        label->SetTextL( KNullDesC );
        label->ConstructL(
            iEnableMarquee && ( index == ETextTrack ) );

        label->SetBackground( iBackground );
        User::LeaveIfError( iLabels.Append( label ) );
        CleanupStack::Pop( label );
        }
    }

// ---------------------------------------------------------------------------
// Creates icons.
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::CreateIconsL()
    {
    FreeIcons();

    // Play/stop/pause icons
    iPlayIcon =
        iLayout->GetIndicatorIconMaskL( EIconPlay );
    iPauseIcon =
        iLayout->GetIndicatorIconMaskL(EIconPause );

    // Repeat, random, etc
    iRepeatAllIcon =
        iLayout->GetIndicatorIconMaskL( EIconRepeatAll );
    iRepeatOneIcon =
        iLayout->GetIndicatorIconMaskL( EIconRepeatOne );
    iRandomIcon =
        iLayout->GetIndicatorIconMaskL( EIconRandom );
#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER
    iRealIcon =
        iLayout->GetIndicatorIconMaskL( EIconReal );
#endif

    // Download slider
    iDownloadSlider = iLayout->GetIndicatorIconMaskL(
        EDownloadSlider );
    iPlaybackSlider = iLayout->GetIndicatorIconMaskL(
        EPlaybackSlider );
    iSliderBackground = iLayout->GetIndicatorIconMaskL(
        ESliderBackground );

    // Default album art
    iDefaultAlbumArt = iLayout->GetIndicatorIconMaskL(
        EAlbumArtArea );
    }

// ---------------------------------------------------------------------------
// Deletes all icon objects.
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::FreeIcons()
    {
    delete iPauseIcon;
    iPauseIcon = NULL;
    delete iPlayIcon;
    iPlayIcon = NULL;
    delete iRandomIcon;
    iRandomIcon = NULL;
    delete iRepeatOneIcon;
    iRepeatOneIcon = NULL;
    delete iRepeatAllIcon;
    iRepeatAllIcon = NULL;
    delete iDownloadSlider;
    iDownloadSlider = NULL;
    delete iPlaybackSlider;
    iPlaybackSlider = NULL;
    delete iSliderBackground;
    iSliderBackground = NULL;
    delete iDefaultAlbumArt;
    iDefaultAlbumArt = NULL;
#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER
    delete iRealIcon;
    iRealIcon = NULL;
#endif
    }

// ---------------------------------------------------------------------------
// Draw an icon
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::DrawIndicator(
    CWindowGc& aGc ,
    const TRect& aDirtyRect,
    const TRect& aIndicatorRect,
    const CGulIcon* aIcon,
    TBool aInvertMask ) const
    {
    if ( aIcon && aIndicatorRect.Intersects( aDirtyRect ) )
        {
        aGc.BitBltMasked(
            aIndicatorRect.iTl,
            aIcon->Bitmap(),
            TRect( aIndicatorRect.Size() ),
            aIcon->Mask(),
            aInvertMask );
        }
    }

// ---------------------------------------------------------------------------
// Redraw part of the screen.
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::RedrawRect(
    const TRect& aRect) const
    {
	CWindowGc& gc = SystemGc();
    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

	AknsDrawUtils::Background( skin, iBackground,
			this, gc, aRect );

    TBool embedded = iEikonEnv->StartedAsServerApp();

    if ( iPrerollCompleted )
        {
        if ( iRepeatAllMode && !embedded )
            {
            DrawIndicator( gc, aRect, iRepeatIconRect, iRepeatAllIcon );
            }

        if ( iRepeatOneMode && !embedded )
            {
            DrawIndicator(gc, aRect, iRepeatIconRect, iRepeatOneIcon);
            }

        if ( iRandomMode && !embedded )
            {
            DrawIndicator(gc, aRect, iRandomIconRect, iRandomIcon);
            }

#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER
        if ( iRealAudioMode )
            {
            DrawIndicator( gc, aRect, iRealIconRect, iRealIcon );
            }
#endif

        DrawIndicator( gc, aRect, iSliderBackgroundRect, iSliderBackground );
        if ( iMode == EPlayMode || iMode == EPauseMode )
            {

            DrawIndicator( gc, aRect, TRect(iDownloadSliderRect.iTl,
                    iDownloadSlider->Bitmap()->SizeInPixels()),
                    iDownloadSlider );
            DrawIndicator(gc, aRect, TRect(iPlaybackSliderRect.iTl,
                    iPlaybackSlider->Bitmap()->SizeInPixels() ),
                    iPlaybackSlider );
            }

        if ( iDisplayAlbumArt && aRect.Intersects( iAlbumArtRect ) )
            {
            if ( iTrackAlbumArt )
                {
                // Draw album art and frame
                gc.DrawBitmap( iAlbumArtRect, iTrackAlbumArt, iTrackAlbumArt->SizeInPixels() );
                
                TRgb color = KRgbBlack;
                AknsUtils::GetCachedColor( skin, color, KAknsIIDQsnTextColors,
                        EAknsCIQsnTextColorsCG50 );
                gc.SetPenStyle( CGraphicsContext::ESolidPen );
                gc.SetBrushStyle( CGraphicsContext::ENullBrush );
                gc.SetPenColor( color );
                gc.DrawRect( iAlbumArtRect );                    
                }
            else
                {
                DrawIndicator( gc, aRect, iAlbumArtRect, iDefaultAlbumArt );
                }
            }
        }
    }

// ---------------------------------------------------------------------------
// Update progress bar graphics based on current playback
// and download position.
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::UpdateProgressBarGraphics()
    {
    MPX_FUNC("CMPXCommonPlaybackViewContainer::UpdateProgressBarGraphics()");
    TSize downloadBarSize = iDownloadSliderRect.Size();
    TSize playbackBarSize = iPlaybackSliderRect.Size();

    downloadBarSize.iWidth *= iDownloadRatio;
    playbackBarSize.iWidth *= iPlaybackRatio;

    AknIconUtils::SetSize(
        iDownloadSlider->Bitmap(),
        downloadBarSize,
        EAspectRatioNotPreserved );
    AknIconUtils::SetSize(
        iPlaybackSlider->Bitmap(),
        playbackBarSize,
        EAspectRatioNotPreserved );
    }

// ---------------------------------------------------------------------------
// Update progress bar graphics and redraw.
// Refresh happens only when backlight is ON and
// the UI is in foreground.
// Note: Some display types may not need backlight. In that case
// code may need to be adjusted accordingly.
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::RefreshProgressBar()
    {
    MPX_FUNC( "CMPXCommonPlaybackViewContainer::RefreshProgressBar" );

    MPX_DEBUG2(" iIsForeground : (%d)", iIsForeground);
    MPX_DEBUG2(" iLightStatus : (%d)", iLightStatus);

    if ( iIsForeground && (iLightStatus == CHWRMLight::ELightOn) )
		{
		UpdateProgressBarGraphics();
		Window().Invalidate( iSliderPaneRect );
		}
    }

// ---------------------------------------------------------------------------
// Update label text color according to skin
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::UpdateLabelColorsL()
    {
    MAknsSkinInstance* skin = AknsUtils::SkinInstance();
    TRgb color = KRgbBlack;
    // Color is not updated if it not found from the skin
    AknsUtils::GetCachedColor(
        skin,
        color,
        KAknsIIDQsnTextColors,
        EAknsCIQsnTextColorsCG6 );

    for ( TInt i = 0; i < iLabels.Count(); i++ )
        {
        AknLayoutUtils::OverrideControlColorL(
            *iLabels[i],
            EColorLabelText,
            color );
        }
    }

// ---------------------------------------------------------------------------
// Update skin control context for background
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::UpdateBackgroundSkinControlContext(
    const TRect& aRect )
    {
    CAknsBasicBackgroundControlContext* background =
        static_cast<CAknsBasicBackgroundControlContext*>( iBackground );
    if ( Layout_Meta_Data::IsLandscapeOrientation() )
        {
        TAknWindowLineLayout screenLayout =
            AknLayout::screen();
        TRect screenRect = screenLayout.Rect();
        background->SetBitmap( KAknsIIDQsnBgAreaMain );
        background->SetRect( screenRect );

        }
    else
        {
        background->SetBitmap( KAknsIIDQsnBgAreaMain );
        background->SetRect( aRect );
        }

    }

// ---------------------------------------------------------------------------
// Set FMTX mode.
// FMTX label shouldn't appear in some playback views
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::SetFMTXMode(
    TBool aFMTXMode )
    {
	if ( FeatureManager::FeatureSupported( KFeatureIdFmtx ) )
		{
	    iFMTXMode = aFMTXMode;
		}
    }

// ---------------------------------------------------------------------------
// From CCoeControl
// Responds to changes to the size and position of the contents of this
// control.
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::SizeChanged()
    {
    MPX_FUNC("CMPXCommonPlaybackViewContainer::SizeChanged()");
    UpdateLayout();
    UpdateBackgroundSkinControlContext( Rect() );
    }

// ---------------------------------------------------------------------------
// From CCoeControl
// Gets the number of controls contained in a compound control.
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CMPXCommonPlaybackViewContainer::CountComponentControls() const
    {
    if(iPrerollCompleted)
        {
        return KLabelCount + 1; // ButtonManager
        }
    else
        {
        return 0;
        }
   }
// ---------------------------------------------------------------------------
// From CCoeControl
// Gets an indexed component of a compound control.
// ---------------------------------------------------------------------------
//
EXPORT_C CCoeControl* CMPXCommonPlaybackViewContainer::ComponentControl( TInt aIndex ) const
    {
    CCoeControl* control = NULL;
    if(iPrerollCompleted)
        {
        if (aIndex < KLabelCount)
            {
            control = iLabels[aIndex];
            }
        else
            {
            control = iButtonManager;
            }
        }

    return control;
    }

// ---------------------------------------------------------------------------
// From CCoeControl
// Draws the control.
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::Draw( const TRect& aRect ) const
    {
    RedrawRect(aRect);
    }

// -----------------------------------------------------------------------------
// CMPXCommonPlaybackViewContainer::HandleButtonCommandL
// -----------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::HandleButtonCommandL( TInt aCommand )
    {
    MPX_DEBUG2("CMPXCommonPlaybackViewContainer::HandleButtonCommandL(%d) entering", aCommand);
    if ( iCommandObserver )
        {
        iCommandObserver->ProcessCommandL( aCommand );
        }
    MPX_DEBUG1("CMPXCommonPlaybackViewContainer::HandleButtonCommandL() exiting");
    }

// ---------------------------------------------------------------------------
// CMPXCommonPlaybackViewContainer::HandlePointerEventL
// ---------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::HandlePointerEventL(const TPointerEvent& aPointerEvent)
    {
    MPX_DEBUG1( "CMPXCommonPlaybackViewContainer::HandlePointerEventL" );
    if(AknLayoutUtils::PenEnabled())
        {
        TSize playbackBarSize = iPlaybackSliderRect.Size();
        TReal width;
        switch( aPointerEvent.iType )
            {
            case TPointerEvent::EButton1Down:
                {
                if ( iSliderPaneRect.Contains(aPointerEvent.iPosition) &&
                        ( iMode == EPlayMode || iMode == EPauseMode ))
                    {
                    // Pointer events
                    SetGloballyCapturing( ETrue );
                    SetPointerCapture( ETrue );

                    MPX_DEBUG1( "CMPXCommonPlaybackViewContainer::HandlePointerEventL btnDOWN" );
                    iTouchDown = ETrue;
                    width = aPointerEvent.iPosition.iX - iSliderBackgroundRect.iTl.iX;
                    playbackBarSize.iWidth = width;
                    AknIconUtils::SetSize(
                        iPlaybackSlider->Bitmap(),
                        playbackBarSize,
                        EAspectRatioNotPreserved );
                    }
                if ( iAlbumArtRect.Contains(aPointerEvent.iPosition ) )
                    {
                    MTouchFeedback* feedback = MTouchFeedback::Instance();
                    if (feedback)
                        {
                        feedback->InstantFeedback(ETouchFeedbackPopUp);
                        }

                    if ( iCommandObserver )
        								{
                        iCommandObserver->ProcessCommandL( EMPXCmdVolumeChanged );
                        }
                    }
                break;
                }

            case TPointerEvent::EDrag:
                {
                if(iTouchDown && ( iMode == EPlayMode || iMode == EPauseMode ) )
                    {
                    MPX_DEBUG1( "CMPXCommonPlaybackViewContainer::HandlePointerEventL ****btnDrag****" );

                    MTouchFeedback* feedback = MTouchFeedback::Instance();
                    if (feedback)
                        {
                        feedback->InstantFeedback(ETouchFeedbackSensitive);
                        }

                    if (aPointerEvent.iPosition.iX <= iSliderBackgroundRect.iTl.iX)
                        {
                        width = 0;
                        }
                    else if (aPointerEvent.iPosition.iX >= iSliderBackgroundRect.iBr.iX)
                        {
                        width = iSliderBackgroundRect.iBr.iX - iSliderBackgroundRect.iTl.iX;
                        }
                    else
                        {
                        width = aPointerEvent.iPosition.iX - iSliderBackgroundRect.iTl.iX;
                        }

                    playbackBarSize.iWidth = width;
                    AknIconUtils::SetSize(
                        iPlaybackSlider->Bitmap(),
                        playbackBarSize,
                        EAspectRatioNotPreserved );

                    // Update the ellapsed and remaining time texts for user feedback
                    TReal totalWidth = iPlaybackSliderRect.Width();
                    TReal ratio = width/totalWidth;
                    TInt newSongPositionInSec = ratio * iTrackTotalLengthInSeconds;
                                CMPXCommonUiHelper::TMPXDuratDisplayMode durationMode =
                    CMPXCommonUiHelper::EMPXDuratAuto;
                    if ( iTrackTotalLengthInSeconds > KOneHourInSeconds )
                        {
                        durationMode = CMPXCommonUiHelper::EMPXDuratHMS;
                        }

                    // Convert ellapsed time to text
                    HBufC* position = iCommonUiHelper->DisplayableDurationL(
                        newSongPositionInSec,
                        durationMode );
                    CleanupStack::PushL( position );

                    TInt remainingTime = iTrackTotalLengthInSeconds - newSongPositionInSec;
                    if ( remainingTime < 0 )
                        {
                        remainingTime = 0;
                        }

                    // Convert remaining time to text
                    HBufC* remaining = iCommonUiHelper->DisplayableDurationL(
                        remainingTime,
                        durationMode );
                    CleanupStack::PushL( remaining );

                    UpdateLabelL( ETextElapsedTime, *position );
                    UpdateLabelL( ETextRemainingTime, *remaining );
                    CleanupStack::PopAndDestroy( remaining );
                    CleanupStack::PopAndDestroy( position );

                    // Invalidate rect so it will be redrawn immediately
                    Window().Invalidate( iSliderPaneRect );
                    }
                else
                    {
                    SetGloballyCapturing( EFalse );
                    SetPointerCapture( EFalse );
                    iTouchDown = EFalse;
                    }
                break;
                }

            case TPointerEvent::EButton1Up:
                {
                MPX_DEBUG1( "CMPXCommonPlaybackViewContainer::HandlePointerEventL btnUP" );
                if(iTouchDown)
                    {
                    // Pointer events
                    SetGloballyCapturing( EFalse );
                    SetPointerCapture( EFalse );
                    if ( ( iMode == EPlayMode || iMode == EPauseMode ) )
                        {
                        iTouchDown = EFalse;
                        if ( aPointerEvent.iPosition.iX
                                <= iSliderBackgroundRect.iTl.iX )
                            {
                            width = 0;
                            }
                        else if ( aPointerEvent.iPosition.iX
                                >= iSliderBackgroundRect.iBr.iX )
                            {
                            width = iSliderBackgroundRect.iBr.iX
                                    - iSliderBackgroundRect.iTl.iX;
                            }
                        else
                            {
                            width = aPointerEvent.iPosition.iX
                                    - iSliderBackgroundRect.iTl.iX;
                            }
                        playbackBarSize.iWidth = width;
                        AknIconUtils::SetSize( iPlaybackSlider->Bitmap(),
                                playbackBarSize, EAspectRatioNotPreserved );

                        // Set new song position based upon progress bar location
                        TReal totalWidth = iPlaybackSliderRect.Width();
                        TReal ratio = width / totalWidth;
                        iNewSongPosition = (ratio
                                * iTrackTotalLengthInSeconds) * 1000;

                        // Invalidate rect so it will be redrawn immediately
					    Window().Invalidate( iSliderPaneRect );
					    iSeekTimer->Cancel();
					    iSeekTimer->Start( KSeekDelay, KSeekDelay, TCallBack( CallSetPosition, this ) );
					    iDragProgressBar = ETrue;
                        }
                    }
                break;
                }

            default:
                {
                MPX_DEBUG1( "CMPXCommonPlaybackViewContainer::HandlePointerEventL default" );
                break;
                }
            }
        }
    }

// ---------------------------------------------------------------------------
// CMPXCommonPlaybackViewContainer::GetNewSongPosition
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CMPXCommonPlaybackViewContainer::GetNewSongPosition()
    {
    return iNewSongPosition;
    }

// -----------------------------------------------------------------------------
// CMPXCommonPlaybackViewContainer::LightStatusChanged
// -----------------------------------------------------------------------------
//
EXPORT_C void CMPXCommonPlaybackViewContainer::LightStatusChanged( TInt aTarget, CHWRMLight::TLightStatus aStatus )
    {
    MPX_FUNC( "CMPXCommonPlaybackViewContainer::LightStatusChanged" );
    if ( aTarget == CHWRMLight::EPrimaryDisplay )
        {
		MPX_DEBUG2(" LightStatusChanged: (%d)", aStatus);
		if ( ( aStatus == CHWRMLight::ELightOn || aStatus == CHWRMLight::ELightOff ) && aStatus != iLightStatus )
	    	{
			iLightStatus = aStatus;
			}
        }
    }

// ---------------------------------------------------------------------------
// CMPXCommonPlaybackViewContainer::SetNewSongPosition
// ---------------------------------------------------------------------------
//
void CMPXCommonPlaybackViewContainer::SetNewSongPosition( const TInt64& aPositon )
    {
    iNewSongPosition = aPositon;
    }

// ---------------------------------------------------------------------------
// Helper function to set layout for all elements and set sizes for icons.
// ---------------------------------------------------------------------------
//
void CMPXCommonPlaybackViewContainer::DoUpdateLayoutL()
    {
    TRect myRect = Rect();
    if ( myRect == iCurrentLayout )
        {
        // Layout has not changed, do nothing
        return;
        }


    MPX_DEBUG5( "CMPXCommonPlaybackViewContainer::DoUpdateLayoutL() -- new layout: top-left (%d, %d) size (%d, %d)",
        myRect.iTl.iX, myRect.iTl.iY, myRect.Size().iWidth, myRect.Size().iHeight );

    // Get layout data
    iSliderPaneRect = iLayout->IndicatorLayout(
        myRect, ESliderPane );
    iLayout->LayoutLabel(
        iLabels[ETextElapsedTime], iSliderPaneRect, ETextElapsedTime );
    iLayout->LayoutLabel(
        iLabels[ETextRemainingTime], iSliderPaneRect, ETextRemainingTime );
    iLayout->LayoutLabel(
        iLabels[ETextArtist], myRect, ETextArtist );
    iLayout->LayoutLabel(
        iLabels[ETextTrack], myRect, ETextTrack );
    iLayout->LayoutLabel(
        iLabels[ETextPlaylistCount], myRect, ETextPlaylistCount );
    //iLayout->LayoutLabel(
    //    iLabels[ETextEmpty], myRect, ETextEmpty );
    // suppress download text per UI spec
    //iLayout->LayoutLabel(
    //    iLabels[ETextDownloadState], iSliderPaneRect, ETextDownloadState );

   	if ( iFMTXMode )
       	{
       	iLayout->LayoutLabel(
           	iLabels[ETextFMFrequency], myRect, ETextFMFrequency );
       	}

    // Check if the artist and title rects intersect, if so move them
    TRect titleRect = iLabels[ETextTrack]->Rect();
    TRect artistRect = iLabels[ETextArtist]->Rect();
    if ( titleRect.Intersects( artistRect ))
        {
        TRect intersection = titleRect;
        intersection.Intersection( artistRect );
        TInt diff = -(intersection.Height());
        iLayout->LayoutLabel(
            iLabels[ETextTrack], myRect, ETextTrack, 0, diff );
        }

    iIconLayout = iLayout->IndicatorLayout( myRect, EIconPlay );
    iRandomIconRect = iLayout->IndicatorLayout( myRect, EIconRandom );
    iRepeatIconRect = iLayout->IndicatorLayout( myRect, EIconRepeatAll );
    iBackgroundLayout = myRect;

    iDownloadSliderRect = iLayout->IndicatorLayout(
        iSliderPaneRect, EDownloadSlider );
    iPlaybackSliderRect = iLayout->IndicatorLayout(
        iSliderPaneRect, EPlaybackSlider );
    iSliderBackgroundRect = iLayout->IndicatorLayout(
        iSliderPaneRect, ESliderBackground );

    iAlbumArtRect = iLayout->IndicatorLayout(
        myRect, EAlbumArtArea );

#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER
    iRealIconRect = iLayout->IndicatorLayout( myRect, EIconReal );
#endif

    // Scale icons
    if ( iPauseIcon )
        {
        AknIconUtils::SetSize(
            iPauseIcon->Bitmap(), iIconLayout.Size() );
        }
    if ( iPlayIcon )
        {
        AknIconUtils::SetSize(
            iPlayIcon->Bitmap(), iIconLayout.Size() );
        }
    if ( iRandomIcon )
        {
        AknIconUtils::SetSize(
            iRandomIcon->Bitmap(), iRandomIconRect.Size() );
        }
    if ( iRepeatAllIcon )
        {
        AknIconUtils::SetSize(
            iRepeatAllIcon->Bitmap(), iRepeatIconRect.Size() );
        }
    if ( iRepeatOneIcon )
        {
        AknIconUtils::SetSize(
            iRepeatOneIcon->Bitmap(), iRepeatIconRect.Size() );
        }

    if ( iSliderBackground )
        {
        AknIconUtils::SetSize(
            iSliderBackground->Bitmap(),
            iSliderBackgroundRect.Size(),
            EAspectRatioNotPreserved );
        UpdateProgressBarGraphics();
        if ( iMode == EPlayMode || iMode == EPauseMode )
           {
            MTouchFeedback* feedback = MTouchFeedback::Instance();
            if ( feedback )
                {
                feedback->SetFeedbackArea( this, 0, iSliderPaneRect,
                    ETouchFeedbackBasic, ETouchEventStylusDown);
                }
           }
        }

    if ( iDefaultAlbumArt )
        {
        AknIconUtils::SetSize(
            iDefaultAlbumArt->Bitmap(), iAlbumArtRect.Size() );
        }

#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER
    if (iRealIcon)
        {
        AknIconUtils::SetSize(
             iRealIcon->Bitmap(), iRealIconRect.Size() );
        }
#endif

    iCurrentLayout = myRect;

    if ( iEnableButtons )
        {
        if (iButtonManager)
            {
            iButtonManager->SetParentRect( myRect );
            iButtonManager->SetRect(myRect);
            }
        }

    // Update label colors according to skin (ignore the color in layout data)
    UpdateLabelColorsL();

    // update artist/title labels to use the full length of control
    // other controls should not have been clipped in the first place
    if ( iLabels[ ETextTrack ]->FullText().Length() > 0 )
        {
        HBufC* title = iLabels[ ETextTrack ]->FullText().AllocLC();
        iLabels[ ETextTrack ]->SetLabelTextL( *title );
        CleanupStack::PopAndDestroy( title );
        }
    if ( iLabels[ ETextArtist ]->FullText().Length() > 0 )
        {
        HBufC* title = iLabels[ ETextArtist ]->FullText().AllocLC();
        iLabels[ ETextArtist ]->SetLabelTextL( *title );
        CleanupStack::PopAndDestroy( title );
        }

    MPX_DEBUG1( "CMPXCommonPlaybackViewContainer::DoUpdateLayoutL() exiting" );
    }

// -----------------------------------------------------------------------------
// CMPXCommonPlaybackViewContainer::ReStoreButtons
// -----------------------------------------------------------------------------
//
void CMPXCommonPlaybackViewContainer::RestoreButtons(
    TMPXPlaybackState aState )
    {
    if ( iEnableButtons )
        {
        iButtonManager->RestoreButtonStates( aState );
        DrawDeferred();
        }
    }

TInt CMPXCommonPlaybackViewContainer::CallSetPosition()
	{
	TRAP_IGNORE( HandleButtonCommandL( EMPXPbvCmdPosition ) );
	iSeekTimer->Cancel();
	return 0;
	}

TInt CMPXCommonPlaybackViewContainer::CallSetPosition( TAny* aAny )
	{
	return ((CMPXCommonPlaybackViewContainer*)aAny)->CallSetPosition();
	}

// -----------------------------------------------------------------------------
// CMPXCommonPlaybackViewContainer::AdjustOrdinalPosition
// -----------------------------------------------------------------------------
//
void CMPXCommonPlaybackViewContainer::AdjustOrdinalPosition( TInt aNewOrdinalPosition )
    {
    return Window().SetOrdinalPosition( aNewOrdinalPosition );
    }

// -----------------------------------------------------------------------------
// CMPXCommonPlaybackViewContainer::BeginTransition
// -----------------------------------------------------------------------------
//
void CMPXCommonPlaybackViewContainer::BeginTransition()
    {
    iTransitionType = EMPXTranstionToRight;
    const TInt flags = AknTransEffect::TParameter::EActivateExplicitCancel;
    TRect appRect = ((CAknAppUi*)iCoeEnv->AppUi())->ApplicationRect();
    GfxTransEffect::BeginFullScreen( iTransitionType, appRect,
            AknTransEffect::EParameterType, AknTransEffect::GfxTransParam(KAppUidMusicPlayerX, flags));

    // start transition immediately. Other option would be to start it when the album thumb has
    // been received.
    EndTransition();
    }

// -----------------------------------------------------------------------------
// CMPXCommonPlaybackViewContainer::EndTransition
// -----------------------------------------------------------------------------
//
void CMPXCommonPlaybackViewContainer::EndTransition()
    {
    if( iTransitionType != EMPXTranstionNotDefined )
        {
        GfxTransEffect::EndFullScreen();
        iTransitionType = EMPXTranstionNotDefined;
        }
    }


// -----------------------------------------------------------------------------
// CMPXCommonPlaybackViewContainer::SetTransitionType
// -----------------------------------------------------------------------------
//
void CMPXCommonPlaybackViewContainer::SetTransitionType( TTransitionType aTransitionType )
    {
	iTransitionType = aTransitionType;
    }
//  End of File
