/*
* Copyright (c) 2008 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: Media Details Viewer
*
*/


// Version : %version:  18 %


// INCLUDE FILES
#include <eikenv.h>
#include <eiklabel.h>
#include <AknUtils.h>
#include <AknIconUtils.h>
#include <StringLoader.h>
#include <AknsDrawUtils.h>
#include <gulicon.h>
#include <gdi.h>
#include <e32base.h>

#include <mpxfiledetailscntlpluginif.h>
#include <mpxvideoplaybackcontrols.rsg>
#include <mpxvideoplaybackcontrols.mbg>
#include <avkon.rsg>

#include "mpxvideoplaybackcontrol.hrh"
#include "mpxcommonvideoplaybackview.hrh"
#include "mpxvideoplaybackmediadetailsviewer.h"
#include "mpxvideoplaybackcontrolscontroller.h"
#include "mpxvideoplaybackcontainer.h"

// Constants
_LIT(KHeadingValueSeperator, ": ");
_LIT(KWidthHeightSeparator, " \xd7 ");
_LIT(KLeftMargin, " " );

const TInt KMediaDetailsViewerMaxItems = 11;  // used to determine the height of each item
const TInt KMediaDetailsViewerItemMargin = 3;
const TInt KMediaDetailsViewerVisibleCharacters = 30;
const TInt KMediaDetailsViewerFilenameMedium = 45;
const TInt KMediaDetailsViewerOffsetDivisorMedium = 12;
const TInt KMediaDetailsViewerOffsetDivisorMax = 20;
const TInt KMediaDetailsViewerMaxBufLen = 255;

// UID of this interface
const TUid KFileDetailsCntlPluginUid = {0x2002A59D};

const TUint32 KScrollTimerDelayTickCounts = 2000;   // 2000 milliseconds
const TUint32 KInvalidTick = 0;

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

CMPXVideoPlaybackMediaDetailsViewer::CMPXVideoPlaybackMediaDetailsViewer(
    CMPXVideoPlaybackControlsController* aController )
    : iController( aController )
    , iDrmDetailsLaunched( EFalse )
{
}

// -------------------------------------------------------------------------------------------------
// CMPXVideoPlaybackMediaDetailsViewer::ConstructL()
// Symbian 2nd phase constructor can leave.
// -------------------------------------------------------------------------------------------------
//
void CMPXVideoPlaybackMediaDetailsViewer::ConstructL()
{
    MPX_DEBUG(_L("CMPXVideoPlaybackMediaDetailsViewer::ConstructL()"));

    iViewerRect = CalculateViewerRectL();
    SetRect( TRect(0, 0, iViewerRect.Width(), iViewerRect.Height()) );

    CreateLabelsL();
    SkinChangeL();

    iBackgroundBitmap = new ( ELeave ) CFbsBitmap();
    TSize bitmapSize = Rect().Size();
    User::LeaveIfError( iBackgroundBitmap->Create( bitmapSize, EColor16MA ) );

    iScrollingTextTimer = CPeriodic::NewL( CActive::EPriorityStandard );
    iScrollingTextTimer->Start(
                0,
                175000,
                TCallBack( CMPXVideoPlaybackMediaDetailsViewer::ScrollTimer, this ) );
}

// -------------------------------------------------------------------------------------------------
// CMPXVideoPlaybackMediaDetailsViewer::NewL()
// Two-phased constructor.
// -------------------------------------------------------------------------------------------------
//
CMPXVideoPlaybackMediaDetailsViewer* CMPXVideoPlaybackMediaDetailsViewer::NewL(
                                                CMPXVideoPlaybackControlsController* aController )
{
    MPX_DEBUG(_L("CMPXVideoPlaybackMediaDetailsViewer::NewL()"));

    CMPXVideoPlaybackMediaDetailsViewer* self = new ( ELeave ) CMPXVideoPlaybackMediaDetailsViewer( aController );

    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();
    return self;
}

// -------------------------------------------------------------------------------------------------
// CMPXVideoPlaybackMediaDetailsViewer::~CMPXVideoPlaybackMediaDetailsViewer()
// Destructor.
// -------------------------------------------------------------------------------------------------
//
CMPXVideoPlaybackMediaDetailsViewer::~CMPXVideoPlaybackMediaDetailsViewer()
{
    MPX_DEBUG(_L("CMPXVideoPlaybackMediaDetailsViewer::~CMPXVideoPlaybackMediaDetailsViewer()"));

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

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

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

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

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

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

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

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

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

    if ( iScrollingTextTimer )
    {
        iScrollingTextTimer->Cancel();
        delete iScrollingTextTimer;
        iScrollingTextTimer = NULL;
    }

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

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

// -------------------------------------------------------------------------------------------------
// CMPXVideoPlaybackMediaDetailsViewer::HandlePointerEventL()
// -------------------------------------------------------------------------------------------------
//
void CMPXVideoPlaybackMediaDetailsViewer::HandlePointerEventL( const TPointerEvent& aPointerEvent )
{
    MPX_DEBUG(_L("CMPXVideoPlaybackMediaDetailsViewer::HandlePointerEventL()"));

    switch ( aPointerEvent.iType )
    {
        case TPointerEvent::EButton1Down:
        {
            break;
        }
        case TPointerEvent::EButton1Up:
        {
            TRect expandedRect;  //make it a bit easier to click the License label

            if ( iLicenseLabel )
            {
                expandedRect = TRect(iLicenseLabel->Rect().iTl,
                                     TPoint(iLicenseLabel->Rect().iBr.iX,
                                            iLicenseLabel->Rect().iBr.iY * 2 ) );
            }

            if ( iLicenseLabel && expandedRect.Contains(aPointerEvent.iPosition) )
            {
                LaunchDRMDetailsL();
            }
            else
            {
                iController->HandleEventL( EMPXControlCmdCloseFileDetailsViewer );
            }
        }
    }
}

// -------------------------------------------------------------------------------------------------
// CMPXVideoPlaybackMediaDetailsViewer::LaunchDRMDetailsL()
// -------------------------------------------------------------------------------------------------
//
void CMPXVideoPlaybackMediaDetailsViewer::LaunchDRMDetailsL()
{
    if ( ! iDrmDetailsLaunched )
    {
        iDrmDetailsLaunched = ETrue;
        iController->iContainer->HandleCommandL( EMPXPbvLaunchDRMDetails );
        iDrmDetailsLaunched = EFalse;
    }
}

// -------------------------------------------------------------------------------------------------
// CMPXVideoPlaybackMediaDetailsViewer::SkinChangeL()
// -------------------------------------------------------------------------------------------------
//
void CMPXVideoPlaybackMediaDetailsViewer::SkinChangeL()
{
}

// -------------------------------------------------------------------------------------------------
//   CMPXVideoPlaybackMediaDetailsViewer::Draw()
// -------------------------------------------------------------------------------------------------
//
void CMPXVideoPlaybackMediaDetailsViewer::Draw( const TRect& aRect ) const
{
    MPX_DEBUG(_L("CMPXVideoPlaybackMediaDetailsViewer::Draw()"));

    CWindowGc& gc = SystemGc();
    gc.SetClippingRect( aRect );

    this->DrawableWindow()->SetCornerType(EWindowCorner5);

    TRAP_IGNORE( UpdateBackgroundBitmapL() );
    gc.SetDrawMode( CGraphicsContext::EDrawModeWriteAlpha );
    gc.BitBlt( Rect().iTl, iBackgroundBitmap );

    TRAP_IGNORE( FormatLabelsL() );

    gc.SetBrushStyle( CGraphicsContext::ENullBrush );
}

// -------------------------------------------------------------------------------------------------
// CMPXVideoPlaybackMediaDetailsViewer::FormatLabelsL()
// -------------------------------------------------------------------------------------------------
//
void CMPXVideoPlaybackMediaDetailsViewer::FormatLabelsL() const
{
    // FORMAT LABELS


    TInt labelWidth = Rect().iBr.iX;
    TInt labelHeight = iController->iContainer->Rect().iBr.iY / KMediaDetailsViewerMaxItems;
    TInt rowsAdded = 0;

    // License
    if ( iController->FileDetails()->iDrmProtected )
    {
        iLicenseLabel->SetExtent(
                             TPoint(Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded) ) ,
                             TSize( labelWidth, labelHeight )
                             );
        HBufC* heading  = iEikonEnv->AllocReadResourceL( R_MPX_LICENSE_HEADING );
        CleanupStack::PushL( heading );

        TBuf<KMediaDetailsViewerMaxBufLen> licenseField;
        licenseField.Append( KLeftMargin );
        licenseField.Append( *heading );
        iLicenseLabel->OverrideColorL( EColorLabelText, KRgbDarkBlue );
        iLicenseLabel->SetTextL( licenseField );
        iLicenseLabel->SetAllMarginsTo( KMediaDetailsViewerItemMargin );
        iLicenseLabel->SetLabelAlignment( ELayoutAlignCenter );
        iLicenseLabel->SetUnderlining( ETrue );
        iLicenseLabel->MakeVisible( ETrue );
        rowsAdded++;

        CleanupStack::PopAndDestroy( heading );
    }

    // Title
    HBufC* fileTitle = iController->FileDetails()->GenerateFileTitleL();

    if ( fileTitle && fileTitle->Length() )
    {
        // Title gets populated by UpdateTitle method
        iTitleLabel->SetExtent(
                          TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) ,
                          TSize( labelWidth, labelHeight )
                          );
        iTitleLabel->SetAllMarginsTo( KMediaDetailsViewerItemMargin );
        iTitleLabel->MakeVisible( ETrue );
        rowsAdded++;
    }

    delete fileTitle;

    // Filename
    HBufC* fileName = iController->FileDetails()->GenerateFileNameL();

    if ( fileName && fileName->Length() )
    {
        // file name gets populated by UpdateFilename method
        iClipnameLabel->SetExtent(
                             TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) ,
                             TSize( labelWidth, labelHeight )
                             );
        iClipnameLabel->SetAllMarginsTo( KMediaDetailsViewerItemMargin );
        iClipnameLabel->MakeVisible( ETrue );
        rowsAdded++;
    }

    delete fileName;

    // Mime Type (Format)
    if ( iController->FileDetails()->iMimeType && iController->FileDetails()->iMimeType->Length() )
    {
        iFormatLabel->SetExtent(
                          TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) ,
                          TSize( labelWidth, labelHeight )
                          );
        HBufC* heading  = iEikonEnv->AllocReadResourceL( R_MPX_FORMAT_HEADING );
        CleanupStack::PushL( heading );

        TBuf<KMediaDetailsViewerMaxBufLen> formatField;
        formatField.Append( KLeftMargin );
        formatField.Append( *heading );
        formatField.Append( KHeadingValueSeperator );
        TInt allowLen = KMediaDetailsViewerMaxBufLen-formatField.Length();
        formatField.Append( ( iController->FileDetails()->iMimeType )->Left( allowLen ) );
        iFormatLabel->SetTextL( formatField );
        iFormatLabel->SetAllMarginsTo( KMediaDetailsViewerItemMargin );
        iFormatLabel->MakeVisible( ETrue );
        rowsAdded++;

        CleanupStack::PopAndDestroy( heading );
    }

    // Resolution
    if ( iController->FileDetails()->iVideoHeight &&  iController->FileDetails()->iVideoWidth )
    {
        iResolutionLabel->SetExtent(
                               TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) ,
                               TSize( labelWidth, labelHeight )
                               );
        HBufC* heading  = iEikonEnv->AllocReadResourceL( R_MPX_RESOLUTION_HEADING );
        CleanupStack::PushL( heading );

        TBuf<KMediaDetailsViewerMaxBufLen> resolutionField;
        resolutionField.Append( KLeftMargin );
        resolutionField.Append( *heading );
        resolutionField.Append( KHeadingValueSeperator );
        resolutionField.AppendNum( iController->FileDetails()->iVideoWidth );
        resolutionField.Append( KWidthHeightSeparator );
        resolutionField.AppendNum( iController->FileDetails()->iVideoHeight);
        AknTextUtils::DisplayTextLanguageSpecificNumberConversion( resolutionField );

        iResolutionLabel->SetTextL( resolutionField );
        iResolutionLabel->SetAllMarginsTo(KMediaDetailsViewerItemMargin);
        iResolutionLabel->MakeVisible( ETrue );
        rowsAdded++;

        CleanupStack::PopAndDestroy( heading );
    }

    // Duration
    if ( iController->FileDetails()->iDuration > 0 )
    {
        iDurationLabel->SetExtent(
                             TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded) ) ,
                             TSize( labelWidth, labelHeight )
                             );
        HBufC* heading  = iEikonEnv->AllocReadResourceL( R_MPX_DURATION_HEADING );
        CleanupStack::PushL( heading );

        TBuf<KMediaDetailsViewerMaxBufLen> durationField;
        durationField.Append( KLeftMargin );
        durationField.Append( *heading );
        durationField.Append( KHeadingValueSeperator );

        TInt64 durationInSeconds =  iController->FileDetails()->iDuration / 1000;

        HBufC* unitFormatString;

        if ( durationInSeconds < 3600 )  // one hour
        {
            unitFormatString = StringLoader::LoadLC(R_QTN_TIME_DURAT_MIN_SEC);
        }
        else
        {
            unitFormatString = StringLoader::LoadLC(R_QTN_TIME_DURAT_LONG);
        }

        TBuf<64> dur;
        TTime durTime = TTime( durationInSeconds * 1000000 );
        durTime.FormatL( dur, *unitFormatString );
        AknTextUtils::DisplayTextLanguageSpecificNumberConversion( dur );

        durationField.Append( dur );
        iDurationLabel->SetTextL( durationField );
        iDurationLabel->SetAllMarginsTo( KMediaDetailsViewerItemMargin );
        iDurationLabel->MakeVisible( ETrue );
        rowsAdded++;

        CleanupStack::PopAndDestroy( unitFormatString ); // unitFormatString
        CleanupStack::PopAndDestroy( heading );
    }

    // Bitrate
    if ( iController->FileDetails()->iBitRate > 0 )
    {
        iBitrateLabel->SetExtent(
                          TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) ,
                          TSize( labelWidth, labelHeight )
                          );
        HBufC* heading  = iEikonEnv->AllocReadResourceL( R_MPX_BITRATE_HEADING );
        CleanupStack::PushL( heading );

        TBuf<KMediaDetailsViewerMaxBufLen> bitrateField;
        bitrateField.Append( KLeftMargin );
        bitrateField.Append( *heading );
        bitrateField.Append( KHeadingValueSeperator );

        HBufC* formattedBitrate =
             StringLoader::LoadLC(R_MPX_BITRATE_UNITS,iController->FileDetails()->iBitRate / 1000 );

        bitrateField.Append( *formattedBitrate );
        iBitrateLabel->SetTextL( bitrateField );
        iBitrateLabel->SetAllMarginsTo( KMediaDetailsViewerItemMargin );
        iBitrateLabel->MakeVisible( ETrue );
        rowsAdded++;

        CleanupStack::PopAndDestroy( formattedBitrate ); // formattedBitrate
        CleanupStack::PopAndDestroy( heading );
    }

    // Artist
    if ( iController->FileDetails()->iArtist && iController->FileDetails()->iArtist->Length() )
    {
        iArtistLabel->SetExtent(
                          TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) ,
                          TSize( labelWidth, labelHeight )
                          );
        HBufC* heading  = iEikonEnv->AllocReadResourceL( R_MPX_ARTIST_HEADING );
        CleanupStack::PushL( heading );

        TBuf<KMediaDetailsViewerMaxBufLen> artistField;
        artistField.Append( KLeftMargin );
        artistField.Append( *heading );
        artistField.Append( KHeadingValueSeperator );
        TInt allowLen = KMediaDetailsViewerMaxBufLen-artistField.Length();
        artistField.Append( ( iController->FileDetails()->iArtist )->Left( allowLen ) );
        iArtistLabel->SetTextL( artistField );
        iArtistLabel->SetAllMarginsTo( KMediaDetailsViewerItemMargin );
        iArtistLabel->MakeVisible( ETrue );
        rowsAdded++;

        CleanupStack::PopAndDestroy( heading );
    }

    // Additional Label
    if ( iAdditionalString && iAdditionalString->Length() )
    {
        iAdditionalLabel->SetExtent(
                               TPoint( Rect().iTl.iX, Rect().iTl.iY + ( labelHeight * rowsAdded ) ) ,
                               TSize( labelWidth, labelHeight )
                               );

        TBuf<KMediaDetailsViewerMaxBufLen> titleField;
        titleField.Append( KLeftMargin );
        TInt allowLen = KMediaDetailsViewerMaxBufLen-titleField.Length();
        titleField.Append( iAdditionalString->Left( allowLen ) );
        iAdditionalLabel->SetTextL( titleField );
        iAdditionalLabel->SetAllMarginsTo( KMediaDetailsViewerItemMargin );
        iAdditionalLabel->MakeVisible( ETrue );
        rowsAdded++;
    }
}

// -------------------------------------------------------------------------------------------------
// CMPXVideoPlaybackMediaDetailsViewer::CountComponentControls()
// -------------------------------------------------------------------------------------------------
//
TInt CMPXVideoPlaybackMediaDetailsViewer::CountComponentControls() const
{
    return 9;
}

// -------------------------------------------------------------------------------------------------
// CMPXVideoPlaybackMediaDetailsViewer::ComponentControl
// -------------------------------------------------------------------------------------------------
//
CCoeControl* CMPXVideoPlaybackMediaDetailsViewer::ComponentControl(TInt aIndex) const
{
    CCoeControl* control = NULL;

    switch ( aIndex )
    {
        case 0:
            control = iClipnameLabel;
            break;
        case 1:
            control = iTitleLabel;
            break;
        case 2:
            control = iArtistLabel;
            break;
        case 3:
            control = iFormatLabel;
            break;
        case 4:
            control = iResolutionLabel;
            break;
        case 5:
            control = iDurationLabel;
            break;
        case 6:
            control = iBitrateLabel;
            break;
        case 7:
            control = iLicenseLabel;
            break;
        case 8:
            control = iAdditionalLabel;
            break;
        default:
            break;
    }

    return control;
}

// -------------------------------------------------------------------------------------------------
// CMPXVideoPlaybackMediaDetailsViewer::Reset
// -------------------------------------------------------------------------------------------------
//
void CMPXVideoPlaybackMediaDetailsViewer::Reset()
{
}

// -------------------------------------------------------------------------------------------------
// CMPXVideoPlaybackMediaDetailsViewer::CreateLabelsL
// -------------------------------------------------------------------------------------------------
//
void CMPXVideoPlaybackMediaDetailsViewer::CreateLabelsL()
{
    // Licence / DRM
    iLicenseLabel = new (ELeave) CEikLabel;
    iLicenseLabel->SetContainerWindowL( *this );
    iLicenseLabel->SetTextL( KNullDesC );

    // Filename
    iClipnameLabel = new (ELeave) CEikLabel;
    iClipnameLabel->SetContainerWindowL( *this );
    iClipnameLabel->SetTextL( KNullDesC );
    iClipnameLabel->SetLabelAlignment( ELayoutAlignBidi );

    // Title
    iTitleLabel = new (ELeave) CEikLabel;
    iTitleLabel->SetContainerWindowL( *this );
    iTitleLabel->SetTextL( KNullDesC );
    iTitleLabel->SetLabelAlignment( ELayoutAlignBidi );

    // Artist
    iArtistLabel = new (ELeave) CEikLabel;
    iArtistLabel->SetContainerWindowL( *this );
    iArtistLabel->SetTextL( KNullDesC );
    iArtistLabel->SetLabelAlignment( ELayoutAlignBidi );

    // Format
    iFormatLabel = new (ELeave) CEikLabel;
    iFormatLabel->SetContainerWindowL( *this );
    iFormatLabel->SetTextL( KNullDesC );
    iFormatLabel->SetLabelAlignment( ELayoutAlignBidi );

    // Resolution
    iResolutionLabel = new (ELeave) CEikLabel;
    iResolutionLabel->SetContainerWindowL( *this );
    iResolutionLabel->SetTextL( KNullDesC );
    iResolutionLabel->SetLabelAlignment( ELayoutAlignBidi );

    // Duration
    iDurationLabel = new (ELeave) CEikLabel;
    iDurationLabel->SetContainerWindowL( *this );
    iDurationLabel->SetTextL( KNullDesC );
    iDurationLabel->SetLabelAlignment( ELayoutAlignBidi );

    // Bitrate
    iBitrateLabel = new (ELeave) CEikLabel;
    iBitrateLabel->SetContainerWindowL( *this );
    iBitrateLabel->SetTextL( KNullDesC );
    iBitrateLabel->SetLabelAlignment( ELayoutAlignBidi );

    // Additional Labels
    iAdditionalLabel = new (ELeave) CEikLabel;
    iAdditionalLabel->SetContainerWindowL( *this );
    iAdditionalLabel->SetTextL( KNullDesC );
    iAdditionalLabel->SetLabelAlignment( ELayoutAlignBidi );
}

// -----------------------------------------------------------------------------
// CMPXVideoPlaybackMediaDetailsViewer::UpdateBackgroundBitmapL
// Update background bitmap
// -----------------------------------------------------------------------------
//
void CMPXVideoPlaybackMediaDetailsViewer::UpdateBackgroundBitmapL() const
{
    TSize bitmapSize = Rect().Size();

    CFbsBitmapDevice* bgBitmapDevice = CFbsBitmapDevice::NewL( iBackgroundBitmap );
    CleanupStack::PushL( bgBitmapDevice );

    CFbsBitGc* bgBitGc( NULL );
    User::LeaveIfError( bgBitmapDevice->CreateContext( bgBitGc ) );
    CleanupStack::PushL( bgBitGc );

    bgBitGc->SetBrushColor( TRgb(0x708090) );  // slate gray
    bgBitGc->Clear();

    CleanupStack::PopAndDestroy( bgBitGc );
    CleanupStack::PopAndDestroy( bgBitmapDevice );

    // Dither alpha channel for semitransparency
    //
    // Scan line length in 32-bit words
    TInt scanLineLengthWord = CFbsBitmap::ScanLineLength( bitmapSize.iWidth, EColor16MA) / 4;

    iBackgroundBitmap->LockHeap();
    TUint32* dataAddr = reinterpret_cast<TUint32*>( iBackgroundBitmap->DataAddress() );

    for ( TInt y = 0; y < bitmapSize.iHeight; y++ )
    {
        for ( TInt x = 0; x < bitmapSize.iWidth; x++ )
        {
            if ( ( y + x ) & 1 )
            {
                // Make this pixel transparent
                dataAddr[y * scanLineLengthWord + x] = 0x00000000;
            }
        }
    }

    iBackgroundBitmap->UnlockHeap();
}

// -------------------------------------------------------------------------------------------------
// CMPXVideoPlaybackMediaDetailsViewer::ScrollTimer
// -------------------------------------------------------------------------------------------------
//
TInt CMPXVideoPlaybackMediaDetailsViewer::ScrollTimer( TAny* aPtr )
{
    TRAP_IGNORE(
            static_cast<CMPXVideoPlaybackMediaDetailsViewer*>(aPtr)->HandleScrollTimerL()
            );
    return KErrNone;
}

// -------------------------------------------------------------------------------------------------
// CMPXVideoPlaybackMediaDetailsViewer::HandleScrollTimerL
// -------------------------------------------------------------------------------------------------
//
void CMPXVideoPlaybackMediaDetailsViewer::HandleScrollTimerL()
{
    MPX_ENTER_EXIT( _L( "CMPXVideoPlaybackMediaDetailsViewer::HandleScrollTimerL" ) );

    if ( iFilenameScroller.IsUpdateNeeded() )
    {
        UpdateFilenameL();
    }

    if ( iTitleScroller.IsUpdateNeeded() )
    {
        UpdateTitleL();
    }

    if ( !iFilenameScroller.IsScrollNeeded() && !iTitleScroller.IsScrollNeeded() )
    {
        iScrollingTextTimer->Cancel();   // no need to keep the timer active
    }

    if ( iScrolledTextUpdated )
    {
        iScrolledTextUpdated = EFalse;
        DrawNow();
    }
}

// -------------------------------------------------------------------------------------------------
//   CMPXVideoPlaybackMediaDetailsViewer::NumOfItemsShownInViewer
// -------------------------------------------------------------------------------------------------
//
TInt CMPXVideoPlaybackMediaDetailsViewer::NumOfItemsShownInViewerL()
{
    TInt numOfItems = 0;

    if ( iController->FileDetails()->iDrmProtected )
    {
        numOfItems++;
    }

    if ( iController->FileDetails()->iClipName )
    {
        numOfItems++;
    }

    if ( iController->FileDetails()->iMimeType )
    {
        numOfItems++;
    }

    if ( iController->FileDetails()->iVideoHeight &&
         iController->FileDetails()->iVideoWidth )
    {
        numOfItems++;
    }

    if ( iController->FileDetails()->iDuration > 0 )
    {
        numOfItems++;
    }

    if ( iController->FileDetails()->iBitRate > 0 )
    {
        numOfItems++;
    }

    HBufC* title = NULL;
    TRAP_IGNORE ( title = iController->FileDetails()->GenerateFileTitleL() );

    if ( title )
    {
        numOfItems++;
        delete title;
    }

    if ( iController->FileDetails()->iArtist )
    {
        numOfItems++;
    }

    // Additional File Details
    CMPXFileDetailsPlugin* addPlugin( NULL );

    // Use the interface to load the ecom plugin
    TRAPD ( err, addPlugin = CMPXFileDetailsPlugin::NewL( KFileDetailsCntlPluginUid ) );

    // If plugin loaded successfully
    if ( ! err )
    {
        TPtrC addLabel;
        addLabel.Set( addPlugin->GetAdditionalLabelLC( iController->FileDetails()->iFourCCCode ) );
        iAdditionalString = addLabel.AllocL();

        if ( iAdditionalString->Length() )
        {
            numOfItems++;
        }

        CleanupStack::PopAndDestroy();  // addLabel
    }

    delete addPlugin;

    return numOfItems;
}

// -------------------------------------------------------------------------------------------------
//   CMPXVideoPlaybackMediaDetailsViewer::CalculateViewerRect
// -------------------------------------------------------------------------------------------------
//
TRect CMPXVideoPlaybackMediaDetailsViewer::CalculateViewerRectL()
{
    TInt numOfItems = NumOfItemsShownInViewerL();
    TRect viewerRect;

    // optimize viewer's width for the clipname
    TInt horizontalOffset = 0;
    TInt filenameLength = iController->FileDetails()->iClipName->Des().Length();

    if ( filenameLength <= KMediaDetailsViewerFilenameMedium )
    {
        horizontalOffset =
            iController->iContainer->Rect().iBr.iX / KMediaDetailsViewerOffsetDivisorMedium;
    }
    else
    {
        horizontalOffset =
            iController->iContainer->Rect().iBr.iX / KMediaDetailsViewerOffsetDivisorMax;
    }

    TInt eachItemHeight = iController->iContainer->Rect().iBr.iY / KMediaDetailsViewerMaxItems;

    TInt verticalHalf = iController->iContainer->Rect().iBr.iY / 2;

    TInt tLX = (iController->iContainer->Rect().iTl.iX) + horizontalOffset;
    TInt bRX = (iController->iContainer->Rect().iBr.iX) - horizontalOffset;

    TInt tLY = verticalHalf - ( eachItemHeight * numOfItems/2 );

    // pad for the margins on top and bottom of viewer
    TInt bRY =
        verticalHalf + ( eachItemHeight * numOfItems/2 ) + ( KMediaDetailsViewerItemMargin * 2 );

    viewerRect = TRect( tLX, tLY, bRX, bRY );

    return viewerRect;
}

// -------------------------------------------------------------------------------------------------
//   CMPXVideoPlaybackMediaDetailsViewer::UpdateFilenameL
// -------------------------------------------------------------------------------------------------
//
void CMPXVideoPlaybackMediaDetailsViewer::UpdateFilenameL()
{
    MPX_ENTER_EXIT( _L( "CMPXVideoPlaybackMediaDetailsViewer::UpdateFilenameL" ) );

    HBufC* fileName = iController->FileDetails()->GenerateFileNameL();
    CleanupStack::PushL( fileName );

    if ( fileName && fileName->Length() )
    {
        HBufC* heading  = iEikonEnv->AllocReadResourceL( R_MPX_FILENAME_HEADING );
        CleanupStack::PushL( heading );

        TBuf<KMediaDetailsViewerMaxBufLen> filenameField;
        filenameField.Append( KLeftMargin );
        filenameField.Append( *heading );
        filenameField.Append( KHeadingValueSeperator );

        iFilenameScroller.ScrollText( *fileName, filenameField );

        iClipnameLabel->SetTextL( filenameField );

        iScrolledTextUpdated = ETrue;

        CleanupStack::PopAndDestroy( heading );
    }

    CleanupStack::PopAndDestroy( fileName );
}

// -------------------------------------------------------------------------------------------------
//   CMPXVideoPlaybackMediaDetailsViewer::UpdateTitleL
// -------------------------------------------------------------------------------------------------
//
void CMPXVideoPlaybackMediaDetailsViewer::UpdateTitleL()
{
    MPX_ENTER_EXIT( _L( "CMPXVideoPlaybackMediaDetailsViewer::UpdateTitleL" ) );

    HBufC* fileTitle = iController->FileDetails()->GenerateFileTitleL();
    CleanupStack::PushL( fileTitle );

    if ( fileTitle && fileTitle->Length() )
    {
        HBufC* heading  = iEikonEnv->AllocReadResourceL( R_MPX_TITLE_HEADING );
        CleanupStack::PushL( heading );

        TBuf<KMediaDetailsViewerMaxBufLen> titleField;
        titleField.Append( KLeftMargin );
        titleField.Append( *heading );
        titleField.Append( KHeadingValueSeperator );

        iTitleScroller.ScrollText( *fileTitle, titleField );

        iTitleLabel->SetTextL( titleField );

        iScrolledTextUpdated = ETrue;

        CleanupStack::PopAndDestroy( heading );
    }

    CleanupStack::PopAndDestroy( fileTitle );
}

// -------------------------------------------------------------------------------------------------
//   CMPXVideoPlaybackMediaDetailsViewer::ViewerRect
// -------------------------------------------------------------------------------------------------
//
TRect CMPXVideoPlaybackMediaDetailsViewer::ViewerRect()
{
    return iViewerRect;
}

// -------------------------------------------------------------------------------------------------
//   CMPXVideoPlaybackMediaDetailsViewer::TTextScroller::TTextScroller
// -------------------------------------------------------------------------------------------------
//
CMPXVideoPlaybackMediaDetailsViewer::TTextScroller::TTextScroller()
    : iDelayBeginningTick( KInvalidTick )
    , iTextScrollPos( 0 )
    , iDelay( EFalse )
    , iScroll( ETrue )
    , iSrcTextLen( 0 )
{
}

// -------------------------------------------------------------------------------------------------
//   CMPXVideoPlaybackMediaDetailsViewer::TTextScroller::IsScrollNeeded
// -------------------------------------------------------------------------------------------------
//
TBool CMPXVideoPlaybackMediaDetailsViewer::TTextScroller::IsScrollNeeded()
{
    return iScroll;
}

// -------------------------------------------------------------------------------------------------
//   CMPXVideoPlaybackMediaDetailsViewer::TTextScroller::IsUpdateNeeded
// -------------------------------------------------------------------------------------------------
//
TBool CMPXVideoPlaybackMediaDetailsViewer::TTextScroller::IsUpdateNeeded()
{
    MPX_ENTER_EXIT( _L( "CMPXVideoPlaybackMediaDetailsViewer::TTextScroller::IsUpdateNeeded" ) );

    // skip the scrolling operation if the loop for delay is going on
    TBool skipForTimerDelay = EFalse;

    // add a delay after each complete scrolling
    if ( iScroll && iDelayBeginningTick != KInvalidTick )
    {
        if ( ( User::NTickCount() - iDelayBeginningTick ) >= KScrollTimerDelayTickCounts )
        {
            iDelayBeginningTick = KInvalidTick;
        }
        else
        {
            skipForTimerDelay = ETrue;
        }
    }

    // start delay
    if ( iScroll && !skipForTimerDelay && iDelay )
    {
        iDelay = EFalse;
        iDelayBeginningTick = User::NTickCount();
        skipForTimerDelay = ETrue;
    }

    return iScroll && !skipForTimerDelay;
}

// -------------------------------------------------------------------------------------------------
//   CMPXVideoPlaybackMediaDetailsViewer::TTextScroller::ScrollText
// -------------------------------------------------------------------------------------------------
//
void CMPXVideoPlaybackMediaDetailsViewer::TTextScroller::ScrollText(
        const TDesC& aSrcText,
        TDes& aDesText )
{
    MPX_ENTER_EXIT( _L( "CMPXVideoPlaybackMediaDetailsViewer::TTextScroller::ScrollText" ) );

    if ( 0 == iSrcTextLen )
    {
        iSrcTextLen = aSrcText.Length();
    }

    ASSERT( aSrcText.Length() == iSrcTextLen );
    if ( aSrcText.Length() >= KMediaDetailsViewerVisibleCharacters )
    {
        aDesText.Append( aSrcText.Mid( iTextScrollPos,
                KMediaDetailsViewerVisibleCharacters ) );

        if ( iTextScrollPos ==  ( iSrcTextLen - KMediaDetailsViewerVisibleCharacters ) )
        {
            iTextScrollPos = 0;
            iDelay = ETrue;
        }
        else
        {
            iTextScrollPos++;
        }
        iScroll = ETrue;

    }
    else
    {
        aDesText.Append( aSrcText );
        iScroll = EFalse;
    }
}

//  End of File